?????????? ?????????

?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/DeadCode.zip

???????
PK��6(\�\|��$��NodeManipulator/CountManipulator.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeManipulator; use PhpParser\Node\Expr; use PhpParser\Node\Expr\BinaryOp\Greater; use PhpParser\Node\Expr\BinaryOp\GreaterOrEqual; use PhpParser\Node\Expr\BinaryOp\Smaller; use PhpParser\Node\Expr\BinaryOp\SmallerOrEqual; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Scalar\LNumber; use PHPStan\Type\NeverType; use Rector\NodeNameResolver\NodeNameResolver; use Rector\NodeTypeResolver\NodeTypeResolver; use Rector\PhpParser\Comparing\NodeComparator; final class CountManipulator { /** * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @readonly * @var \Rector\PhpParser\Comparing\NodeComparator / private $nodeComparator; /* * @readonly * @var \Rector\NodeTypeResolver\NodeTypeResolver / private $nodeTypeResolver; public function __construct(NodeNameResolver $nodeNameResolver, NodeComparator $nodeComparator, NodeTypeResolver $nodeTypeResolver) { $this->nodeNameResolver = $nodeNameResolver; $this->nodeComparator = $nodeComparator; $this->nodeTypeResolver = $nodeTypeResolver; } public function isCounterHigherThanOne(Expr $firstExpr, Expr $secondExpr) : bool { // e.g. count($values) > 0 if ($firstExpr instanceof Greater) { return $this->isGreater($firstExpr, $secondExpr); } // e.g. count($values) >= 1 if ($firstExpr instanceof GreaterOrEqual) { return $this->isGreaterOrEqual($firstExpr, $secondExpr); } // e.g. 0 < count($values) if ($firstExpr instanceof Smaller) { return $this->isSmaller($firstExpr, $secondExpr); } // e.g. 1 <= count($values) if ($firstExpr instanceof SmallerOrEqual) { return $this->isSmallerOrEqual($firstExpr, $secondExpr); } return \false; } private function isGreater(Greater $greater, Expr $expr) : bool { if (!$this->isNumber($greater->right, 0)) { return \false; } return $this->isCountWithExpression($greater->left, $expr); } private function isGreaterOrEqual(GreaterOrEqual $greaterOrEqual, Expr $expr) : bool { if (!$this->isNumber($greaterOrEqual->right, 1)) { return \false; } return $this->isCountWithExpression($greaterOrEqual->left, $expr); } private function isSmaller(Smaller $smaller, Expr $expr) : bool { if (!$this->isNumber($smaller->left, 0)) { return \false; } return $this->isCountWithExpression($smaller->right, $expr); } private function isSmallerOrEqual(SmallerOrEqual $smallerOrEqual, Expr $expr) : bool { if (!$this->isNumber($smallerOrEqual->left, 1)) { return \false; } return $this->isCountWithExpression($smallerOrEqual->right, $expr); } private function isNumber(Expr $expr, int $value) : bool { if (!$expr instanceof LNumber) { return \false; } return $expr->value === $value; } private function isCountWithExpression(Expr $node, Expr $expr) : bool { if (!$node instanceof FuncCall) { return \false; } if (!$this->nodeNameResolver->isName($node, 'count')) { return \false; } if ($node->isFirstClassCallable()) { return \false; } if (!isset($node->getArgs()[0])) { return \false; } $countedExpr = $node->getArgs()[0]->value; if ($this->nodeComparator->areNodesEqual($countedExpr, $expr)) { $exprType = $this->nodeTypeResolver->getNativeType($expr); if (!$exprType->isArray()->yes()) { return $exprType instanceof NeverType; } return \true; } return \false; } } PK��6(\��4��NodeManipulator/ControllerClassMethodManipulator.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeManipulator; use PhpParser\Node\Name; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PHPStan\PhpDocParser\Ast\PhpDoc\GenericTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\NodeNameResolver\NodeNameResolver; final class ControllerClassMethodManipulator { /* * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(NodeNameResolver $nodeNameResolver, PhpDocInfoFactory $phpDocInfoFactory) { $this->nodeNameResolver = $nodeNameResolver; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function isControllerClassMethod(Class_ $class, ClassMethod $classMethod) : bool { if (!$classMethod->isPublic()) { return \false; } if (!$this->hasParentClassController($class)) { return \false; } $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($classMethod); return $phpDocInfo->hasByType(GenericTagValueNode::class); } private function hasParentClassController(Class_ $class) : bool { if (!$class->extends instanceof Name) { return \false; } $parentClassName = $this->nodeNameResolver->getName($class->extends); if (\substr_compare($parentClassName, 'Controller', -\strlen('Controller')) === 0) { return \true; } return \substr_compare($parentClassName, 'Presenter', -\strlen('Presenter')) === 0; } } PK��6(\��$cb��b��+��NodeManipulator/ClassMethodParamRemover.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeManipulator; use PhpParser\Node\Stmt\ClassMethod; use Rector\NodeAnalyzer\ParamAnalyzer; use Rector\Removing\NodeManipulator\ComplexNodeRemover; final class ClassMethodParamRemover { /* * @readonly * @var \Rector\NodeAnalyzer\ParamAnalyzer / private $paramAnalyzer; /* * @readonly * @var \Rector\Removing\NodeManipulator\ComplexNodeRemover / private $complexNodeRemover; public function __construct(ParamAnalyzer $paramAnalyzer, ComplexNodeRemover $complexNodeRemover) { $this->paramAnalyzer = $paramAnalyzer; $this->complexNodeRemover = $complexNodeRemover; } public function processRemoveParams(ClassMethod $classMethod) : ?ClassMethod { $paramKeysToBeRemoved = []; foreach ($classMethod->params as $key => $param) { if ($this->paramAnalyzer->isParamUsedInClassMethod($classMethod, $param)) { continue; } $paramKeysToBeRemoved[] = $key; } if ($paramKeysToBeRemoved === []) { return null; } $removedParamKeys = $this->complexNodeRemover->processRemoveParamWithKeys($classMethod, $paramKeysToBeRemoved); if ($removedParamKeys !== []) { return $classMethod; } return null; } } PK��6(\��d��d��)��NodeManipulator/LivingCodeManipulator.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeManipulator; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\ArrayDimFetch; use PhpParser\Node\Expr\BinaryOp; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use PhpParser\Node\Expr\BinaryOp\BooleanOr; use PhpParser\Node\Expr\BinaryOp\Coalesce; use PhpParser\Node\Expr\BinaryOp\LogicalAnd; use PhpParser\Node\Expr\BinaryOp\LogicalOr; use PhpParser\Node\Expr\BitwiseNot; use PhpParser\Node\Expr\BooleanNot; use PhpParser\Node\Expr\Cast; use PhpParser\Node\Expr\ClassConstFetch; use PhpParser\Node\Expr\Clone_; use PhpParser\Node\Expr\Closure; use PhpParser\Node\Expr\ConstFetch; use PhpParser\Node\Expr\Empty_; use PhpParser\Node\Expr\Instanceof_; use PhpParser\Node\Expr\Isset_; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Expr\UnaryMinus; use PhpParser\Node\Expr\UnaryPlus; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Scalar; use PHPStan\Type\ObjectType; use Rector\NodeTypeResolver\NodeTypeResolver; final class LivingCodeManipulator { /* * @readonly * @var \Rector\NodeTypeResolver\NodeTypeResolver / private $nodeTypeResolver; public function __construct(NodeTypeResolver $nodeTypeResolver) { $this->nodeTypeResolver = $nodeTypeResolver; } /* * @return Expr[]\|mixed[] * @param \PhpParser\Node\|int\|string\|null $expr / public function keepLivingCodeFromExpr($expr) : array { if (!$expr instanceof Expr) { return []; } if ($expr instanceof Closure \|\| $expr instanceof Scalar \|\| $expr instanceof ConstFetch) { return []; } if ($this->isNestedExpr($expr)) { return $this->keepLivingCodeFromExpr($expr->expr); } if ($expr instanceof Variable) { return $this->keepLivingCodeFromExpr($expr->name); } if ($expr instanceof PropertyFetch) { return \array_merge($this->keepLivingCodeFromExpr($expr->var), $this->keepLivingCodeFromExpr($expr->name)); } if ($expr instanceof ArrayDimFetch) { $type = $this->nodeTypeResolver->getType($expr->var); if ($type instanceof ObjectType) { $objectType = new ObjectType('ArrayAccess'); if ($objectType->isSuperTypeOf($type)->yes()) { return [$expr]; } } return \array_merge($this->keepLivingCodeFromExpr($expr->var), $this->keepLivingCodeFromExpr($expr->dim)); } if ($expr instanceof ClassConstFetch \|\| $expr instanceof StaticPropertyFetch) { return \array_merge($this->keepLivingCodeFromExpr($expr->class), $this->keepLivingCodeFromExpr($expr->name)); } if ($this->isBinaryOpWithoutChange($expr)) { /* @var BinaryOp $binaryOp / $binaryOp = $expr; return $this->processBinary($binaryOp); } if ($expr instanceof Instanceof_) { return \array_merge($this->keepLivingCodeFromExpr($expr->expr), $this->keepLivingCodeFromExpr($expr->class)); } if ($expr instanceof Isset_) { return $this->processIsset($expr); } return [$expr]; } private function isNestedExpr(Expr $expr) : bool { return $expr instanceof Cast \|\| $expr instanceof Empty_ \|\| $expr instanceof UnaryMinus \|\| $expr instanceof UnaryPlus \|\| $expr instanceof BitwiseNot \|\| $expr instanceof BooleanNot \|\| $expr instanceof Clone_; } private function isBinaryOpWithoutChange(Expr $expr) : bool { if (!$expr instanceof BinaryOp) { return \false; } return !($expr instanceof LogicalAnd \|\| $expr instanceof BooleanAnd \|\| $expr instanceof LogicalOr \|\| $expr instanceof BooleanOr \|\| $expr instanceof Coalesce); } /* * @return Expr[] / private function processBinary(BinaryOp $binaryOp) : array { return \array_merge($this->keepLivingCodeFromExpr($binaryOp->left), $this->keepLivingCodeFromExpr($binaryOp->right)); } /* * @return mixed[] / private function processIsset(Isset_ $isset) : array { $livingExprs = []; foreach ($isset->vars as $expr) { $livingExprs = \array_merge($livingExprs, $this->keepLivingCodeFromExpr($expr)); } return $livingExprs; } } PK��6(\͐�v��v��0��NodeManipulator/VariadicFunctionLikeDetector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeManipulator; use PhpParser\Node; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\FunctionLike; use PhpParser\NodeTraverser; use Rector\NodeNameResolver\NodeNameResolver; use Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser; final class VariadicFunctionLikeDetector { /* * @readonly * @var \Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser / private $simpleCallableNodeTraverser; /* * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @var string[] / private const VARIADIC_FUNCTION_NAMES = ['func_get_arg', 'func_get_args', 'func_num_args']; public function __construct(SimpleCallableNodeTraverser $simpleCallableNodeTraverser, NodeNameResolver $nodeNameResolver) { $this->simpleCallableNodeTraverser = $simpleCallableNodeTraverser; $this->nodeNameResolver = $nodeNameResolver; } /* * @api / public function isVariadic(FunctionLike $functionLike) : bool { $isVariadic = \false; $this->simpleCallableNodeTraverser->traverseNodesWithCallable((array) $functionLike->getStmts(), function (Node $node) use(&$isVariadic) : ?int { if (!$node instanceof FuncCall) { return null; } if (!$this->nodeNameResolver->isNames($node, self::VARIADIC_FUNCTION_NAMES)) { return null; } $isVariadic = \true; return NodeTraverser::STOP_TRAVERSAL; }); return $isVariadic; } } PK��6(\�ڕ�� &��PhpDoc/DeadVarTagValueNodeAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc; use PhpParser\Node\Stmt\Property; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use PHPStan\Type\IntersectionType; use PHPStan\Type\ObjectType; use PHPStan\Type\TypeCombinator; use PHPStan\Type\UnionType; use Rector\DeadCode\PhpDoc\Guard\TemplateTypeRemovalGuard; use Rector\NodeTypeResolver\TypeComparator\TypeComparator; use Rector\StaticTypeMapper\StaticTypeMapper; final class DeadVarTagValueNodeAnalyzer { /* * @readonly * @var \Rector\NodeTypeResolver\TypeComparator\TypeComparator / private $typeComparator; /* * @readonly * @var \Rector\StaticTypeMapper\StaticTypeMapper / private $staticTypeMapper; /* * @readonly * @var \Rector\DeadCode\PhpDoc\Guard\TemplateTypeRemovalGuard / private $templateTypeRemovalGuard; public function __construct(TypeComparator $typeComparator, StaticTypeMapper $staticTypeMapper, TemplateTypeRemovalGuard $templateTypeRemovalGuard) { $this->typeComparator = $typeComparator; $this->staticTypeMapper = $staticTypeMapper; $this->templateTypeRemovalGuard = $templateTypeRemovalGuard; } public function isDead(VarTagValueNode $varTagValueNode, Property $property) : bool { if ($property->type === null) { return \false; } if ($varTagValueNode->description !== '') { return \false; } // is strict type superior to doc type? keep strict type only $propertyType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($property->type); $docType = $this->staticTypeMapper->mapPHPStanPhpDocTypeNodeToPHPStanType($varTagValueNode->type, $property); if (!$this->templateTypeRemovalGuard->isLegal($docType)) { return \false; } if ($propertyType instanceof UnionType && !$docType instanceof UnionType) { return !$docType instanceof IntersectionType; } if ($propertyType instanceof ObjectType && $docType instanceof ObjectType) { // more specific type is already in the property return $docType->isSuperTypeOf($propertyType)->yes(); } if ($this->typeComparator->arePhpParserAndPhpStanPhpDocTypesEqual($property->type, $varTagValueNode->type, $property)) { return \true; } return $docType instanceof UnionType && $this->typeComparator->areTypesEqual(TypeCombinator::removeNull($docType), $propertyType); } } PK��6(\��Q!��!��(��PhpDoc/DeadParamTagValueNodeAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc; use PhpParser\Node\FunctionLike; use PhpParser\Node\Name; use PhpParser\Node\Param; use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode; use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger; use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode; use Rector\DeadCode\PhpDoc\Guard\StandaloneTypeRemovalGuard; use Rector\DeadCode\PhpDoc\Guard\TemplateTypeRemovalGuard; use Rector\DeadCode\TypeNodeAnalyzer\GenericTypeNodeAnalyzer; use Rector\DeadCode\TypeNodeAnalyzer\MixedArrayTypeNodeAnalyzer; use Rector\NodeNameResolver\NodeNameResolver; use Rector\NodeTypeResolver\TypeComparator\TypeComparator; use Rector\StaticTypeMapper\StaticTypeMapper; use Rector\TypeDeclaration\NodeAnalyzer\ParamAnalyzer; final class DeadParamTagValueNodeAnalyzer { /* * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @readonly * @var \Rector\NodeTypeResolver\TypeComparator\TypeComparator / private $typeComparator; /* * @readonly * @var \Rector\DeadCode\TypeNodeAnalyzer\GenericTypeNodeAnalyzer / private $genericTypeNodeAnalyzer; /* * @readonly * @var \Rector\DeadCode\TypeNodeAnalyzer\MixedArrayTypeNodeAnalyzer / private $mixedArrayTypeNodeAnalyzer; /* * @readonly * @var \Rector\TypeDeclaration\NodeAnalyzer\ParamAnalyzer / private $paramAnalyzer; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger / private $phpDocTypeChanger; /* * @readonly * @var \Rector\DeadCode\PhpDoc\Guard\StandaloneTypeRemovalGuard / private $standaloneTypeRemovalGuard; /* * @readonly * @var \Rector\StaticTypeMapper\StaticTypeMapper / private $staticTypeMapper; /* * @readonly * @var \Rector\DeadCode\PhpDoc\Guard\TemplateTypeRemovalGuard / private $templateTypeRemovalGuard; public function __construct(NodeNameResolver $nodeNameResolver, TypeComparator $typeComparator, GenericTypeNodeAnalyzer $genericTypeNodeAnalyzer, MixedArrayTypeNodeAnalyzer $mixedArrayTypeNodeAnalyzer, ParamAnalyzer $paramAnalyzer, PhpDocTypeChanger $phpDocTypeChanger, StandaloneTypeRemovalGuard $standaloneTypeRemovalGuard, StaticTypeMapper $staticTypeMapper, TemplateTypeRemovalGuard $templateTypeRemovalGuard) { $this->nodeNameResolver = $nodeNameResolver; $this->typeComparator = $typeComparator; $this->genericTypeNodeAnalyzer = $genericTypeNodeAnalyzer; $this->mixedArrayTypeNodeAnalyzer = $mixedArrayTypeNodeAnalyzer; $this->paramAnalyzer = $paramAnalyzer; $this->phpDocTypeChanger = $phpDocTypeChanger; $this->standaloneTypeRemovalGuard = $standaloneTypeRemovalGuard; $this->staticTypeMapper = $staticTypeMapper; $this->templateTypeRemovalGuard = $templateTypeRemovalGuard; } public function isDead(ParamTagValueNode $paramTagValueNode, FunctionLike $functionLike) : bool { $param = $this->paramAnalyzer->getParamByName($paramTagValueNode->parameterName, $functionLike); if (!$param instanceof Param) { return \false; } if ($param->type === null) { return \false; } if ($paramTagValueNode->description !== '') { return \false; } $docType = $this->staticTypeMapper->mapPHPStanPhpDocTypeNodeToPHPStanType($paramTagValueNode->type, $functionLike); if (!$this->templateTypeRemovalGuard->isLegal($docType)) { return \false; } if ($param->type instanceof Name && $this->nodeNameResolver->isName($param->type, 'object')) { return $paramTagValueNode->type instanceof IdentifierTypeNode && (string) $paramTagValueNode->type === 'object'; } if (!$this->typeComparator->arePhpParserAndPhpStanPhpDocTypesEqual($param->type, $paramTagValueNode->type, $functionLike)) { return \false; } if ($this->phpDocTypeChanger->isAllowed($paramTagValueNode->type)) { return \false; } if (!$paramTagValueNode->type instanceof BracketsAwareUnionTypeNode) { return $this->standaloneTypeRemovalGuard->isLegal($paramTagValueNode->type, $param->type); } return $this->isAllowedBracketAwareUnion($paramTagValueNode->type); } private function isAllowedBracketAwareUnion(BracketsAwareUnionTypeNode $bracketsAwareUnionTypeNode) : bool { if ($this->mixedArrayTypeNodeAnalyzer->hasMixedArrayType($bracketsAwareUnionTypeNode)) { return \false; } return !$this->genericTypeNodeAnalyzer->hasGenericType($bracketsAwareUnionTypeNode); } } PK��6(\�)��)��PhpDoc/Guard/TemplateTypeRemovalGuard.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc\Guard; use PHPStan\Type\Type; use PHPStan\Type\UnionType; use PHPStan\Type\Generic\TemplateType; final class TemplateTypeRemovalGuard { public function isLegal(Type $docType) : bool { // cover direct \PHPStan\Type\Generic\TemplateUnionType if ($docType instanceof TemplateType) { return \false; } // cover mixed template with mix from @template and non @template $types = $docType instanceof UnionType ? $docType->getTypes() : [$docType]; foreach ($types as $type) { if ($type instanceof TemplateType) { return \false; } } return \true; } } PK��6(\� ��+��PhpDoc/Guard/StandaloneTypeRemovalGuard.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc\Guard; use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; use PHPStan\PhpDocParser\Ast\Type\TypeNode; final class StandaloneTypeRemovalGuard { /* * @var string[] / private const ALLOWED_TYPES = ['false', 'true']; public function isLegal(TypeNode $typeNode, Node $node) : bool { if (!$typeNode instanceof IdentifierTypeNode) { return \true; } if (!$node instanceof Identifier) { return \true; } if ($node->toString() !== 'bool') { return \true; } return !\in_array($typeNode->name, self::ALLOWED_TYPES, \true); } } PK��6(\H`�n��)��PhpDoc/DeadReturnTagValueNodeAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc; use PhpParser\Node; use PhpParser\Node\Identifier; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Function_; use PHPStan\Analyser\Scope; use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode; use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; use PHPStan\PhpDocParser\Ast\Type\ThisTypeNode; use PHPStan\Type\TypeCombinator; use PHPStan\Type\UnionType; use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger; use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode; use Rector\DeadCode\PhpDoc\Guard\StandaloneTypeRemovalGuard; use Rector\DeadCode\PhpDoc\Guard\TemplateTypeRemovalGuard; use Rector\DeadCode\TypeNodeAnalyzer\GenericTypeNodeAnalyzer; use Rector\DeadCode\TypeNodeAnalyzer\MixedArrayTypeNodeAnalyzer; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\NodeTypeResolver\TypeComparator\TypeComparator; use Rector\StaticTypeMapper\StaticTypeMapper; final class DeadReturnTagValueNodeAnalyzer { /* * @readonly * @var \Rector\NodeTypeResolver\TypeComparator\TypeComparator / private $typeComparator; /* * @readonly * @var \Rector\DeadCode\TypeNodeAnalyzer\GenericTypeNodeAnalyzer / private $genericTypeNodeAnalyzer; /* * @readonly * @var \Rector\DeadCode\TypeNodeAnalyzer\MixedArrayTypeNodeAnalyzer / private $mixedArrayTypeNodeAnalyzer; /* * @readonly * @var \Rector\DeadCode\PhpDoc\Guard\StandaloneTypeRemovalGuard / private $standaloneTypeRemovalGuard; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger / private $phpDocTypeChanger; /* * @readonly * @var \Rector\StaticTypeMapper\StaticTypeMapper / private $staticTypeMapper; /* * @readonly * @var \Rector\DeadCode\PhpDoc\Guard\TemplateTypeRemovalGuard / private $templateTypeRemovalGuard; public function __construct(TypeComparator $typeComparator, GenericTypeNodeAnalyzer $genericTypeNodeAnalyzer, MixedArrayTypeNodeAnalyzer $mixedArrayTypeNodeAnalyzer, StandaloneTypeRemovalGuard $standaloneTypeRemovalGuard, PhpDocTypeChanger $phpDocTypeChanger, StaticTypeMapper $staticTypeMapper, TemplateTypeRemovalGuard $templateTypeRemovalGuard) { $this->typeComparator = $typeComparator; $this->genericTypeNodeAnalyzer = $genericTypeNodeAnalyzer; $this->mixedArrayTypeNodeAnalyzer = $mixedArrayTypeNodeAnalyzer; $this->standaloneTypeRemovalGuard = $standaloneTypeRemovalGuard; $this->phpDocTypeChanger = $phpDocTypeChanger; $this->staticTypeMapper = $staticTypeMapper; $this->templateTypeRemovalGuard = $templateTypeRemovalGuard; } /* * @param \PhpParser\Node\Stmt\ClassMethod\|\PhpParser\Node\Stmt\Function_ $functionLike / public function isDead(ReturnTagValueNode $returnTagValueNode, $functionLike) : bool { $returnType = $functionLike->getReturnType(); if ($returnType === null) { return \false; } if ($returnTagValueNode->description !== '') { return \false; } $docType = $this->staticTypeMapper->mapPHPStanPhpDocTypeNodeToPHPStanType($returnTagValueNode->type, $functionLike); if (!$this->templateTypeRemovalGuard->isLegal($docType)) { return \false; } $scope = $functionLike->getAttribute(AttributeKey::SCOPE); if ($scope instanceof Scope && $scope->isInTrait() && $returnTagValueNode->type instanceof ThisTypeNode) { return \false; } if (!$this->typeComparator->arePhpParserAndPhpStanPhpDocTypesEqual($returnType, $returnTagValueNode->type, $functionLike)) { return $this->isDeadNotEqual($returnTagValueNode, $returnType, $functionLike); } if ($this->phpDocTypeChanger->isAllowed($returnTagValueNode->type)) { return \false; } if (!$returnTagValueNode->type instanceof BracketsAwareUnionTypeNode) { return $this->standaloneTypeRemovalGuard->isLegal($returnTagValueNode->type, $returnType); } if ($this->genericTypeNodeAnalyzer->hasGenericType($returnTagValueNode->type)) { return \false; } if ($this->mixedArrayTypeNodeAnalyzer->hasMixedArrayType($returnTagValueNode->type)) { return \false; } return !$this->hasTrueFalsePseudoType($returnTagValueNode->type); } private function isVoidReturnType(Node $node) : bool { return $node instanceof Identifier && $node->toString() === 'void'; } private function isNeverReturnType(Node $node) : bool { return $node instanceof Identifier && $node->toString() === 'never'; } /* * @param \PhpParser\Node\Stmt\ClassMethod\|\PhpParser\Node\Stmt\Function_ $functionLike / private function isDeadNotEqual(ReturnTagValueNode $returnTagValueNode, Node $node, $functionLike) : bool { if ($returnTagValueNode->type instanceof IdentifierTypeNode && (string) $returnTagValueNode->type === 'void') { return \true; } if (!$this->hasUsefullPhpdocType($returnTagValueNode, $node)) { return \true; } $nodeType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($node); $docType = $this->staticTypeMapper->mapPHPStanPhpDocTypeNodeToPHPStanType($returnTagValueNode->type, $functionLike); return $docType instanceof UnionType && $this->typeComparator->areTypesEqual(TypeCombinator::removeNull($docType), $nodeType); } private function hasTrueFalsePseudoType(BracketsAwareUnionTypeNode $bracketsAwareUnionTypeNode) : bool { $unionTypes = $bracketsAwareUnionTypeNode->types; foreach ($unionTypes as $unionType) { if (!$unionType instanceof IdentifierTypeNode) { continue; } $name = \strtolower((string) $unionType); if (\in_array($name, ['true', 'false'], \true)) { return \true; } } return \false; } /* * exact different between @return and node return type * @param mixed $returnType / private function hasUsefullPhpdocType(ReturnTagValueNode $returnTagValueNode, $returnType) : bool { if ($returnTagValueNode->type instanceof IdentifierTypeNode && $returnTagValueNode->type->name === 'mixed') { return \false; } if (!$this->isVoidReturnType($returnType)) { return !$this->isNeverReturnType($returnType); } if (!$returnTagValueNode->type instanceof IdentifierTypeNode \|\| (string) $returnTagValueNode->type !== 'never') { return \false; } return !$this->isNeverReturnType($returnType); } } PK��6(\Z�=PZ��Z��&��PhpDoc/TagRemover/ReturnTagRemover.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc\TagRemover; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Function_; use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\DeadCode\PhpDoc\DeadReturnTagValueNodeAnalyzer; final class ReturnTagRemover { /* * @readonly * @var \Rector\DeadCode\PhpDoc\DeadReturnTagValueNodeAnalyzer / private $deadReturnTagValueNodeAnalyzer; public function __construct(DeadReturnTagValueNodeAnalyzer $deadReturnTagValueNodeAnalyzer) { $this->deadReturnTagValueNodeAnalyzer = $deadReturnTagValueNodeAnalyzer; } /* * @param \PhpParser\Node\Stmt\ClassMethod\|\PhpParser\Node\Stmt\Function_ $functionLike / public function removeReturnTagIfUseless(PhpDocInfo $phpDocInfo, $functionLike) : bool { // remove existing type $returnTagValueNode = $phpDocInfo->getReturnTagValue(); if (!$returnTagValueNode instanceof ReturnTagValueNode) { return \false; } $isReturnTagValueDead = $this->deadReturnTagValueNodeAnalyzer->isDead($returnTagValueNode, $functionLike); if (!$isReturnTagValueDead) { return \false; } $phpDocInfo->removeByType(ReturnTagValueNode::class); return \true; } } PK��6(\�;�!� �� %��PhpDoc/TagRemover/ParamTagRemover.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc\TagRemover; use PhpParser\Node\FunctionLike; use PHPStan\PhpDocParser\Ast\Node; use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode; use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode; use PHPStan\Type\Type; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\DeadCode\PhpDoc\DeadParamTagValueNodeAnalyzer; use Rector\PhpDocParser\PhpDocParser\PhpDocNodeTraverser; final class ParamTagRemover { /* * @readonly * @var \Rector\DeadCode\PhpDoc\DeadParamTagValueNodeAnalyzer / private $deadParamTagValueNodeAnalyzer; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; public function __construct(DeadParamTagValueNodeAnalyzer $deadParamTagValueNodeAnalyzer, DocBlockUpdater $docBlockUpdater) { $this->deadParamTagValueNodeAnalyzer = $deadParamTagValueNodeAnalyzer; $this->docBlockUpdater = $docBlockUpdater; } public function removeParamTagsIfUseless(PhpDocInfo $phpDocInfo, FunctionLike $functionLike, ?Type $type = null) : bool { $hasChanged = \false; $phpDocNodeTraverser = new PhpDocNodeTraverser(); $phpDocNodeTraverser->traverseWithCallable($phpDocInfo->getPhpDocNode(), '', function (Node $docNode) use($functionLike, &$hasChanged, $type, $phpDocInfo) : ?int { if (!$docNode instanceof PhpDocTagNode) { return null; } if (!$docNode->value instanceof ParamTagValueNode) { return null; } // handle only basic types, keep phpstan/psalm helper ones if ($docNode->name !== '@param') { return null; } if ($type instanceof Type) { $paramType = $phpDocInfo->getParamType($docNode->value->parameterName); if (!$type->equals($paramType)) { return null; } } if (!$this->deadParamTagValueNodeAnalyzer->isDead($docNode->value, $functionLike)) { return null; } $hasChanged = \true; return PhpDocNodeTraverser::NODE_REMOVE; }); if ($hasChanged) { $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($functionLike); } return $hasChanged; } } PK��6(\�{��#��PhpDoc/TagRemover/VarTagRemover.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\PhpDoc\TagRemover; use PhpParser\Node; use PhpParser\Node\Param; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Property; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use PHPStan\Type\Generic\TemplateObjectWithoutClassType; use PHPStan\Type\Type; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\DeadCode\PhpDoc\DeadVarTagValueNodeAnalyzer; use Rector\NodeTypeResolver\TypeComparator\TypeComparator; use Rector\PHPStanStaticTypeMapper\DoctrineTypeAnalyzer; final class VarTagRemover { /* * @readonly * @var \Rector\PHPStanStaticTypeMapper\DoctrineTypeAnalyzer / private $doctrineTypeAnalyzer; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\DeadCode\PhpDoc\DeadVarTagValueNodeAnalyzer / private $deadVarTagValueNodeAnalyzer; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger / private $phpDocTypeChanger; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; /* * @readonly * @var \Rector\NodeTypeResolver\TypeComparator\TypeComparator / private $typeComparator; public function __construct(DoctrineTypeAnalyzer $doctrineTypeAnalyzer, PhpDocInfoFactory $phpDocInfoFactory, DeadVarTagValueNodeAnalyzer $deadVarTagValueNodeAnalyzer, PhpDocTypeChanger $phpDocTypeChanger, DocBlockUpdater $docBlockUpdater, TypeComparator $typeComparator) { $this->doctrineTypeAnalyzer = $doctrineTypeAnalyzer; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->deadVarTagValueNodeAnalyzer = $deadVarTagValueNodeAnalyzer; $this->phpDocTypeChanger = $phpDocTypeChanger; $this->docBlockUpdater = $docBlockUpdater; $this->typeComparator = $typeComparator; } public function removeVarTagIfUseless(PhpDocInfo $phpDocInfo, Property $property) : bool { $varTagValueNode = $phpDocInfo->getVarTagValueNode(); if (!$varTagValueNode instanceof VarTagValueNode) { return \false; } $isVarTagValueDead = $this->deadVarTagValueNodeAnalyzer->isDead($varTagValueNode, $property); if (!$isVarTagValueDead) { return \false; } if ($this->phpDocTypeChanger->isAllowed($varTagValueNode->type)) { return \false; } $phpDocInfo->removeByType(VarTagValueNode::class); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($property); return \true; } /* * @api generic / public function removeVarTag(Node $node) : bool { $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $varTagValueNode = $phpDocInfo->getVarTagValueNode(); if (!$varTagValueNode instanceof VarTagValueNode) { return \false; } $phpDocInfo->removeByType(VarTagValueNode::class); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); return \true; } /* * @param \PhpParser\Node\Stmt\Expression\|\PhpParser\Node\Stmt\Property\|\PhpParser\Node\Param $node / public function removeVarPhpTagValueNodeIfNotComment($node, Type $type) : void { if ($type instanceof TemplateObjectWithoutClassType) { return; } // keep doctrine collection narrow type if ($this->doctrineTypeAnalyzer->isDoctrineCollectionWithIterableUnionType($type)) { return; } $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $varTagValueNode = $phpDocInfo->getVarTagValueNode(); if (!$varTagValueNode instanceof VarTagValueNode) { return; } // has description? keep it if ($varTagValueNode->description !== '') { return; } // keep string[] etc. if ($this->phpDocTypeChanger->isAllowed($varTagValueNode->type)) { return; } // keep subtypes like positive-int if ($this->shouldKeepSubtypes($type, $phpDocInfo->getVarType())) { return; } $phpDocInfo->removeByType(VarTagValueNode::class); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); } private function shouldKeepSubtypes(Type $type, Type $varType) : bool { return !$this->typeComparator->areTypesEqual($type, $varType) && $this->typeComparator->isSubtype($varType, $type); } } PK��6(\��)�g��g��Contract/ConditionInterface.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Contract; interface ConditionInterface { } PK��6(\�ϴ��'��ValueObject/VersionCompareCondition.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\ValueObject; use Rector\DeadCode\Contract\ConditionInterface; final class VersionCompareCondition implements ConditionInterface { /* * @readonly * @var int / private $firstVersion; /* * @readonly * @var int / private $secondVersion; /* * @readonly * @var string\|null / private $compareSign; public function __construct(int $firstVersion, int $secondVersion, ?string $compareSign) { $this->firstVersion = $firstVersion; $this->secondVersion = $secondVersion; $this->compareSign = $compareSign; } public function getFirstVersion() : int { return $this->firstVersion; } public function getSecondVersion() : int { return $this->secondVersion; } public function getCompareSign() : ?string { return $this->compareSign; } } PK��6(\O5�l��/��ValueObject/BinaryToVersionCompareCondition.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\ValueObject; use Rector\DeadCode\Contract\ConditionInterface; final class BinaryToVersionCompareCondition implements ConditionInterface { /* * @readonly * @var \Rector\DeadCode\ValueObject\VersionCompareCondition / private $versionCompareCondition; /* * @readonly * @var string / private $binaryClass; /* * @readonly * @var mixed / private $expectedValue; /* * @param mixed $expectedValue / public function __construct(\Rector\DeadCode\ValueObject\VersionCompareCondition $versionCompareCondition, string $binaryClass, $expectedValue) { $this->versionCompareCondition = $versionCompareCondition; $this->binaryClass = $binaryClass; $this->expectedValue = $expectedValue; } public function getVersionCompareCondition() : \Rector\DeadCode\ValueObject\VersionCompareCondition { return $this->versionCompareCondition; } public function getBinaryClass() : string { return $this->binaryClass; } /* * @return mixed / public function getExpectedValue() { return $this->expectedValue; } } PK��6(\)��-��-��1��NodeAnalyzer/SafeLeftTypeBooleanAndOrAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeAnalyzer; use PhpParser\Node; use PhpParser\Node\Expr\ArrayDimFetch; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use PhpParser\Node\Expr\BinaryOp\BooleanOr; use PhpParser\Node\Expr\CallLike; use PhpParser\Node\Expr\Instanceof_; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Expr\Variable; use PHPStan\Reflection\ClassReflection; use PHPStan\Type\MixedType; use Rector\NodeAnalyzer\ExprAnalyzer; use Rector\NodeTypeResolver\NodeTypeResolver; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Reflection\ReflectionResolver; final class SafeLeftTypeBooleanAndOrAnalyzer { /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @readonly * @var \Rector\NodeAnalyzer\ExprAnalyzer / private $exprAnalyzer; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\NodeTypeResolver\NodeTypeResolver / private $nodeTypeResolver; public function __construct(BetterNodeFinder $betterNodeFinder, ExprAnalyzer $exprAnalyzer, ReflectionResolver $reflectionResolver, NodeTypeResolver $nodeTypeResolver) { $this->betterNodeFinder = $betterNodeFinder; $this->exprAnalyzer = $exprAnalyzer; $this->reflectionResolver = $reflectionResolver; $this->nodeTypeResolver = $nodeTypeResolver; } /* * @param \PhpParser\Node\Expr\BinaryOp\BooleanAnd\|\PhpParser\Node\Expr\BinaryOp\BooleanOr $booleanAnd / public function isSafe($booleanAnd) : bool { $hasNonTypedFromParam = (bool) $this->betterNodeFinder->findFirst($booleanAnd->left, function (Node $node) : bool { return $node instanceof Variable && $this->exprAnalyzer->isNonTypedFromParam($node); }); if ($hasNonTypedFromParam) { return \false; } $hasPropertyFetchOrArrayDimFetch = (bool) $this->betterNodeFinder->findFirst($booleanAnd->left, static function (Node $node) : bool { return $node instanceof PropertyFetch \|\| $node instanceof StaticPropertyFetch \|\| $node instanceof ArrayDimFetch; }); // get type from Property and ArrayDimFetch is unreliable if ($hasPropertyFetchOrArrayDimFetch) { return \false; } // skip trait this $classReflection = $this->reflectionResolver->resolveClassReflection($booleanAnd); if ($classReflection instanceof ClassReflection && $classReflection->isTrait()) { return !$booleanAnd->left instanceof Instanceof_; } return !(bool) $this->betterNodeFinder->findFirst($booleanAnd->left, function (Node $node) : bool { if (!$node instanceof CallLike) { return \false; } $nativeType = $this->nodeTypeResolver->getNativeType($node); return $nativeType instanceof MixedType && !$nativeType->isExplicitMixed(); }); } } PK��6(\�@��'��NodeAnalyzer/ExprUsedInNodeAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeAnalyzer; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Expr\Include_; use PhpParser\Node\Expr\Variable; use Rector\NodeAnalyzer\CompactFuncCallAnalyzer; final class ExprUsedInNodeAnalyzer { /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\UsedVariableNameAnalyzer / private $usedVariableNameAnalyzer; /* * @readonly * @var \Rector\NodeAnalyzer\CompactFuncCallAnalyzer / private $compactFuncCallAnalyzer; public function __construct(\Rector\DeadCode\NodeAnalyzer\UsedVariableNameAnalyzer $usedVariableNameAnalyzer, CompactFuncCallAnalyzer $compactFuncCallAnalyzer) { $this->usedVariableNameAnalyzer = $usedVariableNameAnalyzer; $this->compactFuncCallAnalyzer = $compactFuncCallAnalyzer; } public function isUsed(Node $node, Variable $variable) : bool { if ($node instanceof Include_) { return \true; } // variable as variable variable need mark as used if ($node instanceof Variable && $node->name instanceof Expr) { return \true; } if ($node instanceof FuncCall) { return $this->compactFuncCallAnalyzer->isInCompact($node, $variable); } return $this->usedVariableNameAnalyzer->isVariableNamed($node, $variable); } } PK��6(\�V��)��NodeAnalyzer/UsedVariableNameAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeAnalyzer; use PhpParser\Node; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\Variable; use Rector\NodeNameResolver\NodeNameResolver; final class UsedVariableNameAnalyzer { /* * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; public function __construct(NodeNameResolver $nodeNameResolver) { $this->nodeNameResolver = $nodeNameResolver; } public function isVariableNamed(Node $node, Variable $variable) : bool { if (($node instanceof MethodCall \|\| $node instanceof PropertyFetch) && ($node->name instanceof Variable && \is_string($node->name->name))) { return $this->nodeNameResolver->isName($variable, $node->name->name); } if (!$node instanceof Variable) { return \false; } return $this->nodeNameResolver->areNamesEqual($variable, $node); } } PK��6(\��ݠ����NodeAnalyzer/PropertyWriteonlyAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeAnalyzer; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\NullsafePropertyFetch; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Stmt\Class_; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\PhpParser\Node\BetterNodeFinder; final class PropertyWriteonlyAnalyzer { /** * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; public function __construct(BetterNodeFinder $betterNodeFinder) { $this->betterNodeFinder = $betterNodeFinder; } public function hasClassDynamicPropertyNames(Class_ $class) : bool { return (bool) $this->betterNodeFinder->findFirst($class, static function (Node $node) : bool { if (!$node instanceof PropertyFetch && !$node instanceof NullsafePropertyFetch) { return \false; } // has dynamic name - could be anything return $node->name instanceof Expr; }); } /* * The property fetches are always only assigned to, nothing else * * @param array<PropertyFetch\|StaticPropertyFetch\|NullsafePropertyFetch> $propertyFetches / public function arePropertyFetchesExclusivelyBeingAssignedTo(array $propertyFetches) : bool { foreach ($propertyFetches as $propertyFetch) { if ((bool) $propertyFetch->getAttribute(AttributeKey::IS_MULTI_ASSIGN, \false)) { return \false; } if ((bool) $propertyFetch->getAttribute(AttributeKey::IS_ASSIGNED_TO, \false)) { return \false; } if ((bool) $propertyFetch->getAttribute(AttributeKey::IS_BEING_ASSIGNED, \false)) { continue; } return \false; } return \true; } } PK��6(\X��&��&����NodeAnalyzer/IsClassMethodUsedAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeAnalyzer; use PhpParser\Node; use PhpParser\Node\Arg; use PhpParser\Node\Expr\Array_; use PhpParser\Node\Expr\ArrayItem; use PhpParser\Node\Expr\CallLike; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\NullsafeMethodCall; use PhpParser\Node\Expr\StaticCall; use PhpParser\Node\Name; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Function_; use PhpParser\Node\Stmt\Trait_; use PhpParser\NodeTraverser; use PHPStan\Analyser\Scope; use PHPStan\Parser\ArrayMapArgVisitor; use PHPStan\Reflection\ClassReflection; use Rector\NodeCollector\NodeAnalyzer\ArrayCallableMethodMatcher; use Rector\NodeCollector\ValueObject\ArrayCallable; use Rector\NodeCollector\ValueObject\ArrayCallableDynamicMethod; use Rector\NodeNameResolver\NodeNameResolver; use Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser; use Rector\PhpParser\AstResolver; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\PhpParser\Node\Value\ValueResolver; use Rector\Reflection\ReflectionResolver; final class IsClassMethodUsedAnalyzer { /** * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @readonly * @var \Rector\PhpParser\AstResolver / private $astResolver; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @readonly * @var \Rector\PhpParser\Node\Value\ValueResolver / private $valueResolver; /* * @readonly * @var \Rector\NodeCollector\NodeAnalyzer\ArrayCallableMethodMatcher / private $arrayCallableMethodMatcher; /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\CallCollectionAnalyzer / private $callCollectionAnalyzer; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser / private $simpleCallableNodeTraverser; public function __construct(NodeNameResolver $nodeNameResolver, AstResolver $astResolver, BetterNodeFinder $betterNodeFinder, ValueResolver $valueResolver, ArrayCallableMethodMatcher $arrayCallableMethodMatcher, \Rector\DeadCode\NodeAnalyzer\CallCollectionAnalyzer $callCollectionAnalyzer, ReflectionResolver $reflectionResolver, SimpleCallableNodeTraverser $simpleCallableNodeTraverser) { $this->nodeNameResolver = $nodeNameResolver; $this->astResolver = $astResolver; $this->betterNodeFinder = $betterNodeFinder; $this->valueResolver = $valueResolver; $this->arrayCallableMethodMatcher = $arrayCallableMethodMatcher; $this->callCollectionAnalyzer = $callCollectionAnalyzer; $this->reflectionResolver = $reflectionResolver; $this->simpleCallableNodeTraverser = $simpleCallableNodeTraverser; } public function isClassMethodUsed(Class_ $class, ClassMethod $classMethod, Scope $scope) : bool { $classMethodName = $this->nodeNameResolver->getName($classMethod); // 1. direct normal calls if ($this->isClassMethodCalledInLocalMethodCall($class, $classMethodName)) { return \true; } // 2. direct null-safe calls if ($this->isClassMethodCalledInLocalNullsafeMethodCall($class, $classMethodName)) { return \true; } // 3. direct static calls if ($this->isClassMethodUsedInLocalStaticCall($class, $classMethodName)) { return \true; } // 4. magic array calls! if ($this->isClassMethodCalledInLocalArrayCall($class, $classMethod, $scope)) { return \true; } // 4. private method exists in trait and is overwritten by the class return $this->doesMethodExistInTrait($classMethod, $classMethodName); } private function isClassMethodUsedInLocalStaticCall(Class_ $class, string $classMethodName) : bool { $className = (string) $this->nodeNameResolver->getName($class); /* @var StaticCall[] $staticCalls / $staticCalls = $this->betterNodeFinder->findInstanceOf($class, StaticCall::class); return $this->callCollectionAnalyzer->isExists($staticCalls, $classMethodName, $className); } private function isClassMethodCalledInLocalMethodCall(Class_ $class, string $classMethodName) : bool { $className = (string) $this->nodeNameResolver->getName($class); /* @var MethodCall[] $methodCalls / $methodCalls = $this->betterNodeFinder->findInstanceOf($class, MethodCall::class); return $this->callCollectionAnalyzer->isExists($methodCalls, $classMethodName, $className); } private function isClassMethodCalledInLocalNullsafeMethodCall(Class_ $class, string $classMethodName) : bool { $className = (string) $this->nodeNameResolver->getName($class); /* @var NullsafeMethodCall[] $methodCalls / $methodCalls = $this->betterNodeFinder->findInstanceOf($class, NullsafeMethodCall::class); return $this->callCollectionAnalyzer->isExists($methodCalls, $classMethodName, $className); } private function isInArrayMap(Class_ $class, Array_ $array) : bool { if (!$array->getAttribute(ArrayMapArgVisitor::ATTRIBUTE_NAME) instanceof Arg) { return \false; } if (\count($array->items) !== 2) { return \false; } if (!$array->items[1] instanceof ArrayItem) { return \false; } $value = $this->valueResolver->getValue($array->items[1]->value); if (!\is_string($value)) { return \false; } return $class->getMethod($value) instanceof ClassMethod; } private function isClassMethodCalledInLocalArrayCall(Class_ $class, ClassMethod $classMethod, Scope $scope) : bool { /* @var Array_[] $arrays / $arrays = $this->betterNodeFinder->findInstanceOf($class, Array_::class); $classMethodName = $this->nodeNameResolver->getName($classMethod); foreach ($arrays as $array) { if ($this->isInArrayMap($class, $array)) { return \true; } $arrayCallable = $this->arrayCallableMethodMatcher->match($array, $scope, $classMethodName); if ($arrayCallable instanceof ArrayCallableDynamicMethod) { return \true; } if ($this->shouldSkipArrayCallable($class, $arrayCallable)) { continue; } // the method is used /* @var ArrayCallable $arrayCallable / if ($this->nodeNameResolver->isName($classMethod->name, $arrayCallable->getMethod())) { return \true; } } return \false; } private function shouldSkipArrayCallable(Class_ $class, ?\Rector\NodeCollector\ValueObject\ArrayCallable $arrayCallable) : bool { if (!$arrayCallable instanceof ArrayCallable) { return \true; } // is current class method? return !$this->nodeNameResolver->isName($class, $arrayCallable->getClass()); } private function doesMethodExistInTrait(ClassMethod $classMethod, string $classMethodName) : bool { $classReflection = $this->reflectionResolver->resolveClassReflection($classMethod); if (!$classReflection instanceof ClassReflection) { return \false; } $traits = $this->astResolver->parseClassReflectionTraits($classReflection); $className = $classReflection->getName(); foreach ($traits as $trait) { if ($this->isUsedByTrait($trait, $classMethodName, $className)) { return \true; } } return \false; } private function isUsedByTrait(Trait_ $trait, string $classMethodName, string $className) : bool { foreach ($trait->getMethods() as $classMethod) { if ($classMethod->name->toString() === $classMethodName) { return \true; } /* * Trait can't detect class type, so it rely on "this" or "self" or "static" or "ClassName::methodName()" usage... / $callMethod = null; $this->simpleCallableNodeTraverser->traverseNodesWithCallable((array) $classMethod->stmts, function (Node $subNode) use($className, $classMethodName, &$callMethod) : ?int { if ($subNode instanceof Class_ \|\| $subNode instanceof Function_) { return NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN; } if ($subNode instanceof MethodCall && $this->nodeNameResolver->isName($subNode->var, 'this') && $this->nodeNameResolver->isName($subNode->name, $classMethodName)) { $callMethod = $subNode; return NodeTraverser::STOP_TRAVERSAL; } if ($this->isStaticCallMatch($subNode, $className, $classMethodName)) { $callMethod = $subNode; return NodeTraverser::STOP_TRAVERSAL; } return null; }); if ($callMethod instanceof CallLike) { return \true; } } return \false; } private function isStaticCallMatch(Node $subNode, string $className, string $classMethodName) : bool { if (!$subNode instanceof StaticCall) { return \false; } if (!$subNode->class instanceof Name) { return \false; } return ($subNode->class->isSpecialClassName() \|\| $subNode->class->toString() === $className) && $this->nodeNameResolver->isName($subNode->name, $classMethodName); } } PK��6(\�<;��'��NodeAnalyzer/CallCollectionAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeAnalyzer; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\NullsafeMethodCall; use PhpParser\Node\Expr\StaticCall; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Type\MixedType; use PHPStan\Type\TypeWithClassName; use Rector\Enum\ObjectReference; use Rector\NodeNameResolver\NodeNameResolver; use Rector\NodeTypeResolver\NodeTypeResolver; final class CallCollectionAnalyzer { /* * @readonly * @var \Rector\NodeTypeResolver\NodeTypeResolver / private $nodeTypeResolver; /* * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; public function __construct(NodeTypeResolver $nodeTypeResolver, NodeNameResolver $nodeNameResolver) { $this->nodeTypeResolver = $nodeTypeResolver; $this->nodeNameResolver = $nodeNameResolver; } /* * @param StaticCall[]\|MethodCall[]\|NullsafeMethodCall[] $calls / public function isExists(array $calls, string $classMethodName, string $className) : bool { foreach ($calls as $call) { $callerRoot = $call instanceof StaticCall ? $call->class : $call->var; $callerType = $this->nodeTypeResolver->getType($callerRoot); if (!$callerType instanceof TypeWithClassName) { // handle fluent by $this->bar()->baz()->qux() // that methods don't have return type if ($callerType instanceof MixedType && !$callerType->isExplicitMixed()) { $cloneCallerRoot = clone $callerRoot; $isFluent = \false; // init $methodCallNames = []; // first append $methodCallNames[] = (string) $this->nodeNameResolver->getName($call->name); while ($cloneCallerRoot instanceof MethodCall) { $methodCallNames[] = (string) $this->nodeNameResolver->getName($cloneCallerRoot->name); if ($cloneCallerRoot->var instanceof Variable && $cloneCallerRoot->var->name === 'this') { $isFluent = \true; break; } $cloneCallerRoot = $cloneCallerRoot->var; } if ($isFluent && \in_array($classMethodName, $methodCallNames, \true)) { return \true; } } continue; } if ($this->isSelfStatic($call) && $this->shouldSkip($call, $classMethodName)) { return \true; } if ($callerType->getClassName() !== $className) { continue; } if ($this->shouldSkip($call, $classMethodName)) { return \true; } } return \false; } /* * @param \PhpParser\Node\Expr\MethodCall\|\PhpParser\Node\Expr\StaticCall\|\PhpParser\Node\Expr\NullsafeMethodCall $call / private function isSelfStatic($call) : bool { return $call instanceof StaticCall && $call->class instanceof Name && \in_array($call->class->toString(), [ObjectReference::SELF, ObjectReference::STATIC], \true); } /* * @param \PhpParser\Node\Expr\StaticCall\|\PhpParser\Node\Expr\MethodCall\|\PhpParser\Node\Expr\NullsafeMethodCall $call / private function shouldSkip($call, string $classMethodName) : bool { if (!$call->name instanceof Identifier) { return \true; } // the method is used return $this->nodeNameResolver->isName($call->name, $classMethodName); } } PK��6(\p��ConditionEvaluator.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode; use PhpParser\Node\Expr\BinaryOp\Equal; use PhpParser\Node\Expr\BinaryOp\Identical; use PhpParser\Node\Expr\BinaryOp\NotEqual; use PhpParser\Node\Expr\BinaryOp\NotIdentical; use Rector\DeadCode\Contract\ConditionInterface; use Rector\DeadCode\ValueObject\BinaryToVersionCompareCondition; use Rector\DeadCode\ValueObject\VersionCompareCondition; use Rector\Exception\ShouldNotHappenException; use Rector\Php\PhpVersionProvider; final class ConditionEvaluator { /* * @readonly * @var \Rector\Php\PhpVersionProvider / private $phpVersionProvider; public function __construct(PhpVersionProvider $phpVersionProvider) { $this->phpVersionProvider = $phpVersionProvider; } /* * @return bool\|int\|null / public function evaluate(ConditionInterface $condition) { if ($condition instanceof VersionCompareCondition) { return $this->evaluateVersionCompareCondition($condition); } if ($condition instanceof BinaryToVersionCompareCondition) { return $this->isEvaluedAsTrue($condition); } return null; } /* * @return bool\|int\|null / private function evaluateVersionCompareCondition(VersionCompareCondition $versionCompareCondition) { $compareSign = $versionCompareCondition->getCompareSign(); if ($compareSign !== null) { if ($compareSign === '<' && $this->phpVersionProvider->provide() < $versionCompareCondition->getSecondVersion()) { return null; } return \version_compare((string) $versionCompareCondition->getFirstVersion(), (string) $versionCompareCondition->getSecondVersion(), $compareSign); } return \version_compare((string) $versionCompareCondition->getFirstVersion(), (string) $versionCompareCondition->getSecondVersion()); } private function isEvaluedAsTrue(BinaryToVersionCompareCondition $binaryToVersionCompareCondition) : bool { $versionCompareResult = $this->evaluateVersionCompareCondition($binaryToVersionCompareCondition->getVersionCompareCondition()); if ($binaryToVersionCompareCondition->getBinaryClass() === Identical::class) { return $binaryToVersionCompareCondition->getExpectedValue() === $versionCompareResult; } if ($binaryToVersionCompareCondition->getBinaryClass() === NotIdentical::class) { return $binaryToVersionCompareCondition->getExpectedValue() !== $versionCompareResult; } if ($binaryToVersionCompareCondition->getBinaryClass() === Equal::class) { // weak comparison on purpose return $binaryToVersionCompareCondition->getExpectedValue() === $versionCompareResult; } if ($binaryToVersionCompareCondition->getBinaryClass() === NotEqual::class) { // weak comparison on purpose return $binaryToVersionCompareCondition->getExpectedValue() !== $versionCompareResult; } throw new ShouldNotHappenException(); } } PK��6(\i=E��E��&��UselessIfCondBeforeForeachDetector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Array_; use PhpParser\Node\Expr\BinaryOp\NotEqual; use PhpParser\Node\Expr\BinaryOp\NotIdentical; use PhpParser\Node\Expr\BooleanNot; use PhpParser\Node\Expr\Empty_; use PhpParser\Node\Stmt\If_; use PhpParser\Node\Stmt\Return_; use PHPStan\Analyser\Scope; use Rector\PhpParser\Comparing\NodeComparator; final class UselessIfCondBeforeForeachDetector { /* * @readonly * @var \Rector\PhpParser\Comparing\NodeComparator / private $nodeComparator; public function __construct(NodeComparator $nodeComparator) { $this->nodeComparator = $nodeComparator; } /* * Matches: * empty($values) / public function isMatchingEmptyAndForeachedExpr(If_ $if, Expr $foreachExpr) : bool { if (!$if->cond instanceof Empty_) { return \false; } /* @var Empty_ $empty / $empty = $if->cond; if (!$this->nodeComparator->areNodesEqual($empty->expr, $foreachExpr)) { return \false; } if ($if->stmts === []) { return \true; } if (\count($if->stmts) !== 1) { return \false; } $stmt = $if->stmts[0]; return $stmt instanceof Return_ && !$stmt->expr instanceof Expr; } /* * Matches: * !empty($values) / public function isMatchingNotEmpty(If_ $if, Expr $foreachExpr, Scope $scope) : bool { $cond = $if->cond; if (!$cond instanceof BooleanNot) { return \false; } if (!$cond->expr instanceof Empty_) { return \false; } /* @var Empty_ $empty / $empty = $cond->expr; return $this->areCondExprAndForeachExprSame($empty, $foreachExpr, $scope); } /* * Matches: * $values !== [] * $values != [] * [] !== $values * [] != $values / public function isMatchingNotIdenticalEmptyArray(If_ $if, Expr $foreachExpr) : bool { if (!$if->cond instanceof NotIdentical && !$if->cond instanceof NotEqual) { return \false; } /* @var NotIdentical\|NotEqual $notIdentical / $notIdentical = $if->cond; return $this->isMatchingNotBinaryOp($notIdentical, $foreachExpr); } /* * @param \PhpParser\Node\Expr\BinaryOp\NotIdentical\|\PhpParser\Node\Expr\BinaryOp\NotEqual $binaryOp / private function isMatchingNotBinaryOp($binaryOp, Expr $foreachExpr) : bool { if ($this->isEmptyArrayAndForeachedVariable($binaryOp->left, $binaryOp->right, $foreachExpr)) { return \true; } return $this->isEmptyArrayAndForeachedVariable($binaryOp->right, $binaryOp->left, $foreachExpr); } private function isEmptyArrayAndForeachedVariable(Expr $leftExpr, Expr $rightExpr, Expr $foreachExpr) : bool { if (!$this->isEmptyArray($leftExpr)) { return \false; } return $this->nodeComparator->areNodesEqual($foreachExpr, $rightExpr); } private function isEmptyArray(Expr $expr) : bool { if (!$expr instanceof Array_) { return \false; } return $expr->items === []; } private function areCondExprAndForeachExprSame(Empty_ $empty, Expr $foreachExpr, Scope $scope) : bool { if (!$this->nodeComparator->areNodesEqual($empty->expr, $foreachExpr)) { return \false; } // is array though? $arrayType = $scope->getType($empty->expr); return $arrayType->isArray()->yes(); } } PK��6(\N ��<��<��,��TypeNodeAnalyzer/GenericTypeNodeAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\TypeNodeAnalyzer; use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode; use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode; final class GenericTypeNodeAnalyzer { public function hasGenericType(BracketsAwareUnionTypeNode $bracketsAwareUnionTypeNode) : bool { $types = $bracketsAwareUnionTypeNode->types; foreach ($types as $type) { if ($type instanceof GenericTypeNode) { return \true; } } return \false; } } PK��6(\c38{��{��/��TypeNodeAnalyzer/MixedArrayTypeNodeAnalyzer.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\TypeNodeAnalyzer; use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode; use Rector\BetterPhpDocParser\ValueObject\Type\SpacingAwareArrayTypeNode; final class MixedArrayTypeNodeAnalyzer { public function hasMixedArrayType(BracketsAwareUnionTypeNode $bracketsAwareUnionTypeNode) : bool { $types = $bracketsAwareUnionTypeNode->types; foreach ($types as $type) { if ($type instanceof SpacingAwareArrayTypeNode) { $typeNode = $type->type; if (!$typeNode instanceof IdentifierTypeNode) { continue; } if ($typeNode->name === 'mixed') { return \true; } } } return \false; } } PK��6(\s-�C��5��Rector/Switch_/RemoveDuplicatedCaseInSwitchRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Switch_; use PhpParser\Node; use PhpParser\Node\Stmt\Break_; use PhpParser\Node\Stmt\Case_; use PhpParser\Node\Stmt\Return_; use PhpParser\Node\Stmt\Switch_; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Switch_\RemoveDuplicatedCaseInSwitchRector\RemoveDuplicatedCaseInSwitchRectorTest / final class RemoveDuplicatedCaseInSwitchRector extends AbstractRector { /* * @var bool / private $hasChanged = \false; public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('2 following switch keys with identical will be reduced to one result', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { switch ($name) { case 'clearHeader': return $this->modifyHeader($node, 'remove'); case 'clearAllHeaders': return $this->modifyHeader($node, 'replace'); case 'clearRawHeaders': return $this->modifyHeader($node, 'replace'); case '...': return 5; } } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { switch ($name) { case 'clearHeader': return $this->modifyHeader($node, 'remove'); case 'clearAllHeaders': case 'clearRawHeaders': return $this->modifyHeader($node, 'replace'); case '...': return 5; } } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Switch_::class]; } /* * @param Switch_ $node / public function refactor(Node $node) : ?Node { if (\count($node->cases) < 2) { return null; } $this->hasChanged = \false; $this->removeDuplicatedCases($node); if (!$this->hasChanged) { return null; } return $node; } private function removeDuplicatedCases(Switch_ $switch) : void { $totalKeys = \count($switch->cases); $conds = []; foreach (\array_keys($switch->cases) as $key) { if (isset($switch->cases[$key - 1]) && $switch->cases[$key - 1]->stmts === []) { continue; } $nextCases = []; for ($jumpToKey = $key + 1; $jumpToKey < $totalKeys; ++$jumpToKey) { if (!isset($switch->cases[$jumpToKey])) { continue; } if (!$this->areSwitchStmtsEqualsAndWithBreak($switch->cases[$key], $switch->cases[$jumpToKey])) { continue; } $nextCase = $switch->cases[$jumpToKey]; if (isset($switch->cases[$jumpToKey - 1]) && $switch->cases[$jumpToKey - 1]->stmts === []) { $nextCases[] = $switch->cases[$jumpToKey - 1]; $conds[] = $switch->cases[$jumpToKey - 1]->cond; } unset($switch->cases[$jumpToKey]); $nextCases[] = $nextCase; $this->hasChanged = \true; } if ($nextCases === []) { continue; } \array_splice($switch->cases, $key + 1, 0, $nextCases); for ($jumpToKey = $key; $jumpToKey < $key + \count($nextCases); ++$jumpToKey) { $switch->cases[$jumpToKey]->stmts = []; } $key += \count($nextCases); } foreach ($conds as $keyCond => $cond) { foreach (\array_reverse($switch->cases, \true) as $keyCase => $case) { if ($this->nodeComparator->areNodesEqual($cond, $case->cond)) { unset($switch->cases[$keyCase]); unset($conds[$keyCond]); continue 2; } } } } private function areSwitchStmtsEqualsAndWithBreak(Case_ $currentCase, Case_ $nextCase) : bool { if (!$this->nodeComparator->areNodesEqual($currentCase->stmts, $nextCase->stmts)) { return \false; } foreach ($currentCase->stmts as $stmt) { if ($stmt instanceof Break_) { return \true; } if ($stmt instanceof Return_) { return \true; } } return \false; } } PK��6(\��T��9��Rector/StaticCall/RemoveParentCallWithoutParentRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\StaticCall; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\StaticCall; use PhpParser\Node\Name; use PhpParser\Node\Name\FullyQualified; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\Expression; use PHPStan\Reflection\ReflectionProvider; use Rector\Enum\ObjectReference; use Rector\NodeAnalyzer\ClassAnalyzer; use Rector\NodeManipulator\ClassMethodManipulator; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\StaticCall\RemoveParentCallWithoutParentRector\RemoveParentCallWithoutParentRectorTest / final class RemoveParentCallWithoutParentRector extends AbstractRector { /* * @readonly * @var \Rector\NodeManipulator\ClassMethodManipulator / private $classMethodManipulator; /* * @readonly * @var \Rector\NodeAnalyzer\ClassAnalyzer / private $classAnalyzer; /* * @readonly * @var \PHPStan\Reflection\ReflectionProvider / private $reflectionProvider; public function __construct(ClassMethodManipulator $classMethodManipulator, ClassAnalyzer $classAnalyzer, ReflectionProvider $reflectionProvider) { $this->classMethodManipulator = $classMethodManipulator; $this->classAnalyzer = $classAnalyzer; $this->reflectionProvider = $reflectionProvider; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused parent call with no parent class', [new CodeSample(<<<'CODE_SAMPLE' class OrphanClass { public function __construct() { parent::__construct(); } } CODE_SAMPLE , <<<'CODE_SAMPLE' class OrphanClass { public function __construct() { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Node { if ($this->shouldSkipClass($node)) { return null; } $hasChanged = \false; foreach ($node->getMethods() as $classMethod) { if ($classMethod->stmts === null) { continue; } foreach ($classMethod->stmts as $key => $stmt) { if (!$stmt instanceof Expression) { continue; } if ($stmt->expr instanceof StaticCall && $this->isParentStaticCall($stmt->expr)) { if ($this->doesCalledMethodExistInParent($stmt->expr, $node)) { continue; } unset($classMethod->stmts[$key]); $hasChanged = \true; } if ($stmt->expr instanceof Assign) { $assign = $stmt->expr; if ($assign->expr instanceof StaticCall && $this->isParentStaticCall($assign->expr)) { $staticCall = $assign->expr; // is valid call if ($this->doesCalledMethodExistInParent($staticCall, $node)) { continue; } $assign->expr = $this->nodeFactory->createNull(); $hasChanged = \true; } } } } if ($hasChanged) { return $node; } return null; } private function isParentStaticCall(Expr $expr) : bool { if (!$expr instanceof StaticCall) { return \false; } return $this->isName($expr->class, ObjectReference::PARENT); } private function shouldSkipClass(Class_ $class) : bool { // skip cases when parent class reflection is not found if ($class->extends instanceof FullyQualified && !$this->reflectionProvider->hasClass($class->extends->toString())) { return \true; } // currently the classMethodManipulator isn't able to find usages of anonymous classes return $this->classAnalyzer->isAnonymousClass($class); } private function doesCalledMethodExistInParent(StaticCall $staticCall, Class_ $class) : bool { if (!$class->extends instanceof Name) { return \false; } $calledMethodName = $this->getName($staticCall->name); if (!\is_string($calledMethodName)) { return \false; } return $this->classMethodManipulator->hasParentMethodOrInterfaceMethod($class, $calledMethodName); } } PK��6(\�ң��7��Rector/Return_/RemoveDeadConditionAboveReturnRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Return_; use PhpParser\Node; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Else_; use PhpParser\Node\Stmt\If_; use PhpParser\Node\Stmt\Return_; use PHPStan\Analyser\Scope; use Rector\Contract\PhpParser\Node\StmtsAwareInterface; use Rector\DeadCode\SideEffect\SideEffectNodeDetector; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Return_\RemoveDeadConditionAboveReturnRector\RemoveDeadConditionAboveReturnRectorTest / final class RemoveDeadConditionAboveReturnRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\SideEffect\SideEffectNodeDetector / private $sideEffectNodeDetector; public function __construct(SideEffectNodeDetector $sideEffectNodeDetector) { $this->sideEffectNodeDetector = $sideEffectNodeDetector; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove dead condition above return', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { public function go() { if (1 === 1) { return 'yes'; } return 'yes'; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { public function go() { return 'yes'; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [StmtsAwareInterface::class]; } /* * @param StmtsAwareInterface $node / public function refactor(Node $node) : ?StmtsAwareInterface { foreach ((array) $node->stmts as $key => $stmt) { if (!$stmt instanceof Return_) { continue; } $previousNode = $node->stmts[$key - 1] ?? null; if (!$this->isBareIf($previousNode)) { continue; } /* @var Scope $scope / $scope = $stmt->getAttribute(AttributeKey::SCOPE); /* @var If_ $previousNode / if ($this->sideEffectNodeDetector->detect($previousNode->cond, $scope)) { continue; } $countStmt = \count($previousNode->stmts); if ($countStmt === 0) { unset($node->stmts[$key - 1]); return $node; } if ($countStmt > 1) { return null; } $previousFirstStmt = $previousNode->stmts[0]; if (!$previousFirstStmt instanceof Return_) { return null; } if (!$this->nodeComparator->areNodesEqual($previousFirstStmt, $stmt)) { return null; } unset($node->stmts[$key - 1]); return $node; } return null; } private function isBareIf(?Stmt $stmt) : bool { if (!$stmt instanceof If_) { return \false; } if ($stmt->elseifs !== []) { return \false; } return !$stmt->else instanceof Else_; } } PK��6(\M��4��Rector/Node/RemoveNonExistingVarAnnotationRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Node; use PhpParser\Node; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\CallLike; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Expr\New_; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Echo_; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\If_; use PhpParser\Node\Stmt\InlineHTML; use PhpParser\Node\Stmt\Nop; use PhpParser\Node\Stmt\Return_; use PhpParser\Node\Stmt\Static_; use PhpParser\Node\Stmt\Switch_; use PhpParser\Node\Stmt\Throw_; use PhpParser\Node\Stmt\While_; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\Contract\PhpParser\Node\StmtsAwareInterface; use Rector\NodeManipulator\StmtsManipulator; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\PhpParser\Node\Value\ValueResolver; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Node\RemoveNonExistingVarAnnotationRector\RemoveNonExistingVarAnnotationRectorTest / final class RemoveNonExistingVarAnnotationRector extends AbstractRector { /* * @readonly * @var \Rector\NodeManipulator\StmtsManipulator / private $stmtsManipulator; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\PhpParser\Node\Value\ValueResolver / private $valueResolver; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @var array<class-string<Stmt>> / private const NODE_TYPES = [Foreach_::class, Static_::class, Echo_::class, Return_::class, Expression::class, Throw_::class, If_::class, While_::class, Switch_::class, Nop::class]; public function __construct(StmtsManipulator $stmtsManipulator, DocBlockUpdater $docBlockUpdater, PhpDocInfoFactory $phpDocInfoFactory, ValueResolver $valueResolver, BetterNodeFinder $betterNodeFinder) { $this->stmtsManipulator = $stmtsManipulator; $this->docBlockUpdater = $docBlockUpdater; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->valueResolver = $valueResolver; $this->betterNodeFinder = $betterNodeFinder; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Removes non-existing @var annotations above the code', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function get() { /* @var Training[] $trainings / return $this->getData(); } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function get() { return $this->getData(); } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [StmtsAwareInterface::class]; } /* * @param StmtsAwareInterface $node / public function refactor(Node $node) : ?Node { if ($node->stmts === null) { return null; } $hasChanged = \false; $extractValues = []; foreach ($node->stmts as $key => $stmt) { if ($stmt instanceof Expression && $stmt->expr instanceof FuncCall && $this->isName($stmt->expr, 'extract') && !$stmt->expr->isFirstClassCallable()) { $appendExtractValues = $this->valueResolver->getValue($stmt->expr->getArgs()[0]->value); if (!\is_array($appendExtractValues)) { // nothing can do as value is dynamic break; } $extractValues = \array_merge($extractValues, \array_keys($appendExtractValues)); continue; } if ($this->shouldSkip($node, $key, $stmt, $extractValues)) { continue; } $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($stmt); $varTagValueNode = $phpDocInfo->getVarTagValueNode(); if (!$varTagValueNode instanceof VarTagValueNode) { continue; } if ($this->isObjectShapePseudoType($varTagValueNode)) { continue; } $variableName = \ltrim($varTagValueNode->variableName, '$'); if ($variableName === '' && $this->isAllowedEmptyVariableName($stmt)) { continue; } if ($this->hasVariableName($stmt, $variableName)) { continue; } $comments = $node->getComments(); if (isset($comments[1])) { // skip edge case with double comment, as impossible to resolve by PHPStan doc parser continue; } if ($this->stmtsManipulator->isVariableUsedInNextStmt($node, $key + 1, $variableName)) { continue; } $phpDocInfo->removeByType(VarTagValueNode::class); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($stmt); $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } /* * @param string[] $extractValues / private function shouldSkip(StmtsAwareInterface $stmtsAware, int $key, Stmt $stmt, array $extractValues) : bool { if (!\in_array(\get_class($stmt), self::NODE_TYPES, \true)) { return \true; } if (\count($stmt->getComments()) !== 1) { return \true; } foreach ($extractValues as $extractValue) { if ($this->stmtsManipulator->isVariableUsedInNextStmt($stmtsAware, $key + 1, $extractValue)) { return \true; } } return isset($stmtsAware->stmts[$key + 1]) && $stmtsAware->stmts[$key + 1] instanceof InlineHTML; } private function hasVariableName(Stmt $stmt, string $variableName) : bool { return (bool) $this->betterNodeFinder->findFirst($stmt, function (Node $node) use($variableName) : bool { if (!$node instanceof Variable) { return \false; } return $this->isName($node, $variableName); }); } /* * This is a hack, * that waits on phpdoc-parser to get merged - https://github.com/phpstan/phpdoc-parser/pull/145 / private function isObjectShapePseudoType(VarTagValueNode $varTagValueNode) : bool { if (!$varTagValueNode->type instanceof IdentifierTypeNode) { return \false; } if ($varTagValueNode->type->name !== 'object') { return \false; } if (\strncmp($varTagValueNode->description, '{', \strlen('{')) !== 0) { return \false; } return \strpos($varTagValueNode->description, '}') !== \false; } private function isAllowedEmptyVariableName(Stmt $stmt) : bool { if ($stmt instanceof Return_ && $stmt->expr instanceof CallLike && !$stmt->expr instanceof New_) { return \true; } return $stmt instanceof Expression && $stmt->expr instanceof Assign && $stmt->expr->var instanceof Variable; } } PK��6(\�n;T��T��3��Rector/ConstFetch/RemovePhpVersionIdCheckRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ConstFetch; use PhpParser\Node; use PhpParser\Node\Expr\BinaryOp; use PhpParser\Node\Expr\BinaryOp\Greater; use PhpParser\Node\Expr\BinaryOp\GreaterOrEqual; use PhpParser\Node\Expr\BinaryOp\Smaller; use PhpParser\Node\Expr\ConstFetch; use PhpParser\Node\Scalar\LNumber; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\If_; use PhpParser\NodeTraverser; use Rector\Php\PhpVersionProvider; use Rector\Rector\AbstractRector; use Rector\ValueObject\PhpVersion; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ConstFetch\RemovePhpVersionIdCheckRector\RemovePhpVersionIdCheckRectorTest / final class RemovePhpVersionIdCheckRector extends AbstractRector { /* * @readonly * @var \Rector\Php\PhpVersionProvider / private $phpVersionProvider; /* * @var PhpVersion::\|null / private $phpVersion = null; public function __construct(PhpVersionProvider $phpVersionProvider) { $this->phpVersionProvider = $phpVersionProvider; $this->phpVersion = $this->phpVersionProvider->provide(); } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unneeded PHP_VERSION_ID conditional checks', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { if (PHP_VERSION_ID < 80000) { return; } echo 'do something'; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { echo 'do something'; } } CODE_SAMPLE )]); } /** * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class]; } /* * @param If_ $node * @return null\|int\|Stmt[] / public function refactor(Node $node) { /* * $this->phpVersionProvider->provide() fallback is here as $currentFileProvider must be accessed after initialization / if ($this->phpVersion === null) { $this->phpVersion = $this->phpVersionProvider->provide(); } if (!$node->cond instanceof BinaryOp) { return null; } $binaryOp = $node->cond; if ($binaryOp->left instanceof ConstFetch && $this->isName($binaryOp->left->name, 'PHP_VERSION_ID')) { return $this->refactorConstFetch($binaryOp->left, $node, $binaryOp); } if (!$binaryOp->right instanceof ConstFetch) { return null; } if (!$this->isName($binaryOp->right->name, 'PHP_VERSION_ID')) { return null; } return $this->refactorConstFetch($binaryOp->right, $node, $binaryOp); } /* * @return null\|Stmt[]\|int / private function refactorSmaller(ConstFetch $constFetch, Smaller $smaller, If_ $if) { if ($smaller->left === $constFetch) { return $this->refactorSmallerLeft($smaller); } if ($smaller->right === $constFetch) { return $this->refactorSmallerRight($smaller, $if); } return null; } /* * @return null\|int\|Stmt[] / private function processGreaterOrEqual(ConstFetch $constFetch, GreaterOrEqual $greaterOrEqual, If_ $if) { if ($greaterOrEqual->left === $constFetch) { return $this->refactorGreaterOrEqualLeft($greaterOrEqual, $if); } if ($greaterOrEqual->right === $constFetch) { return $this->refactorGreaterOrEqualRight($greaterOrEqual); } return null; } private function refactorSmallerLeft(Smaller $smaller) : ?int { $value = $smaller->right; if (!$value instanceof LNumber) { return null; } if ($this->phpVersion >= $value->value) { return NodeTraverser::REMOVE_NODE; } return null; } /* * @return null\|Stmt[]\|int / private function refactorSmallerRight(Smaller $smaller, If_ $if) { $value = $smaller->left; if (!$value instanceof LNumber) { return null; } if ($this->phpVersion < $value->value) { return null; } if ($if->stmts === []) { return NodeTraverser::REMOVE_NODE; } return $if->stmts; } /* * @return null\|Stmt[]\|int / private function refactorGreaterOrEqualLeft(GreaterOrEqual $greaterOrEqual, If_ $if) { $value = $greaterOrEqual->right; if (!$value instanceof LNumber) { return null; } if ($this->phpVersion < $value->value) { return null; } if ($if->stmts === []) { return NodeTraverser::REMOVE_NODE; } return $if->stmts; } private function refactorGreaterOrEqualRight(GreaterOrEqual $greaterOrEqual) : ?int { $value = $greaterOrEqual->left; if (!$value instanceof LNumber) { return null; } if ($this->phpVersion >= $value->value) { return NodeTraverser::REMOVE_NODE; } return null; } /* * @return null\|Stmt[]\|int / private function refactorGreater(ConstFetch $constFetch, Greater $greater, If_ $if) { if ($greater->left === $constFetch) { return $this->refactorGreaterLeft($greater, $if); } if ($greater->right === $constFetch) { return $this->refactorGreaterRight($greater); } return null; } /* * @return null\|Stmt[]\|int / private function refactorGreaterLeft(Greater $greater, If_ $if) { $value = $greater->right; if (!$value instanceof LNumber) { return null; } if ($this->phpVersion < $value->value) { return null; } if ($if->stmts === []) { return NodeTraverser::REMOVE_NODE; } return $if->stmts; } private function refactorGreaterRight(Greater $greater) : ?int { $value = $greater->left; if (!$value instanceof LNumber) { return null; } if ($this->phpVersion >= $value->value) { return NodeTraverser::REMOVE_NODE; } return null; } /* * @return null\|Stmt[]\|int / private function refactorConstFetch(ConstFetch $constFetch, If_ $if, BinaryOp $binaryOp) { if ($binaryOp instanceof Smaller) { return $this->refactorSmaller($constFetch, $binaryOp, $if); } if ($binaryOp instanceof GreaterOrEqual) { return $this->processGreaterOrEqual($constFetch, $binaryOp, $if); } if ($binaryOp instanceof Greater) { return $this->refactorGreater($constFetch, $binaryOp, $if); } return null; } } PK��6(\�"s>��>��<��Rector/ClassConst/RemoveUnusedPrivateClassConstantRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassConst; use PhpParser\Node; use PhpParser\Node\Stmt\ClassConst; use PhpParser\NodeTraverser; use PHPStan\Analyser\Scope; use PHPStan\Reflection\ClassReflection; use Rector\NodeManipulator\ClassConstManipulator; use Rector\Rector\AbstractScopeAwareRector; use Rector\Reflection\ReflectionResolver; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassConst\RemoveUnusedPrivateClassConstantRector\RemoveUnusedPrivateClassConstantRectorTest / final class RemoveUnusedPrivateClassConstantRector extends AbstractScopeAwareRector { /* * @readonly * @var \Rector\NodeManipulator\ClassConstManipulator / private $classConstManipulator; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; public function __construct(ClassConstManipulator $classConstManipulator, ReflectionResolver $reflectionResolver) { $this->classConstManipulator = $classConstManipulator; $this->reflectionResolver = $reflectionResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused class constants', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { private const SOME_CONST = 'dead'; public function run() { } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassConst::class]; } /* * @param ClassConst $node / public function refactorWithScope(Node $node, Scope $scope) : ?int { if ($this->shouldSkipClassConst($node, $scope)) { return null; } $classReflection = $this->reflectionResolver->resolveClassReflection($node); if (!$classReflection instanceof ClassReflection) { return null; } if ($this->classConstManipulator->hasClassConstFetch($node, $classReflection)) { return null; } return NodeTraverser::REMOVE_NODE; } private function shouldSkipClassConst(ClassConst $classConst, Scope $scope) : bool { if (!$classConst->isPrivate()) { return \true; } if (\count($classConst->consts) !== 1) { return \true; } $classReflection = $scope->getClassReflection(); if (!$classReflection instanceof ClassReflection) { return \false; } return $this->hasParentClassOfEnumSuffix($classReflection); } private function hasParentClassOfEnumSuffix(ClassReflection $classReflection) : bool { foreach ($classReflection->getParentClassesNames() as $parentClassesName) { if (\substr_compare($parentClassesName, 'Enum', -\strlen('Enum')) === 0) { return \true; } } return \false; } } PK��6(\.��dc��c��$��Rector/For_/RemoveDeadLoopRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\For_; use PhpParser\Node; use PhpParser\Node\Stmt\Do_; use PhpParser\Node\Stmt\For_; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\While_; use PhpParser\NodeTraverser; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\For_\RemoveDeadLoopRector\RemoveDeadLoopRectorTest / final class RemoveDeadLoopRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove loop with no body', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run($values) { for ($i=1; $i<count($values); ++$i) { } } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run($values) { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Do_::class, For_::class, Foreach_::class, While_::class]; } /* * @param Do_\|For_\|Foreach_\|While_ $node / public function refactor(Node $node) : ?int { if ($node->stmts !== []) { return null; } return NodeTraverser::REMOVE_NODE; } } PK��6(\��E��(��Rector/For_/RemoveDeadContinueRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\For_; use PhpParser\Node; use PhpParser\Node\Scalar\LNumber; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Continue_; use PhpParser\Node\Stmt\Do_; use PhpParser\Node\Stmt\For_; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\While_; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\For_\RemoveDeadContinueRector\RemoveDeadContinueRectorTest / final class RemoveDeadContinueRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove useless continue at the end of loops', [new CodeSample(<<<'CODE_SAMPLE' while ($i < 10) { ++$i; continue; } CODE_SAMPLE , <<<'CODE_SAMPLE' while ($i < 10) { ++$i; } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Do_::class, For_::class, Foreach_::class, While_::class]; } /* * @param Do_\|For_\|Foreach_\|While_ $node / public function refactor(Node $node) : ?Node { $modified = \false; while ($this->canRemoveLastStatement($node->stmts)) { \array_pop($node->stmts); $modified = \true; } return $modified ? $node : null; } /* * @param Stmt[] $stmts / private function canRemoveLastStatement(array $stmts) : bool { if ($stmts === []) { return \false; } \end($stmts); $lastKey = \key($stmts); \reset($stmts); $lastStmt = $stmts[$lastKey]; return $this->isRemovable($lastStmt); } private function isRemovable(Stmt $stmt) : bool { if (!$stmt instanceof Continue_) { return \false; } if ($stmt->num instanceof LNumber) { return $stmt->num->value < 2; } return \true; } } PK��6(\�S�A��,��Rector/For_/RemoveDeadIfForeachForRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\For_; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\CallLike; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt\Else_; use PhpParser\Node\Stmt\For_; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\If_; use Rector\Contract\PhpParser\Node\StmtsAwareInterface; use Rector\EarlyReturn\NodeTransformer\ConditionInverter; use Rector\NodeManipulator\StmtsManipulator; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\For_\RemoveDeadIfForeachForRector\RemoveDeadIfForeachForRectorTest / final class RemoveDeadIfForeachForRector extends AbstractRector { /* * @readonly * @var \Rector\EarlyReturn\NodeTransformer\ConditionInverter / private $conditionInverter; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @readonly * @var \Rector\NodeManipulator\StmtsManipulator / private $stmtsManipulator; /* * @var bool / private $hasChanged = \false; public function __construct(ConditionInverter $conditionInverter, BetterNodeFinder $betterNodeFinder, StmtsManipulator $stmtsManipulator) { $this->conditionInverter = $conditionInverter; $this->betterNodeFinder = $betterNodeFinder; $this->stmtsManipulator = $stmtsManipulator; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove if, foreach and for that does not do anything', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run($value) { if ($value) { } foreach ($values as $value) { } return $value; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run($value) { return $value; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [StmtsAwareInterface::class]; } /* * @param StmtsAwareInterface $node * @return \PhpParser\Node\|null\|int / public function refactor(Node $node) { if ($node->stmts === null) { return null; } $this->hasChanged = \false; foreach ($node->stmts as $key => $stmt) { if (!$stmt instanceof If_ && !$stmt instanceof For_ && !$stmt instanceof Foreach_) { continue; } if ($stmt->stmts !== []) { continue; } if ($stmt instanceof If_) { $this->processIf($stmt, $key, $node); continue; } $this->processForForeach($stmt, $key, $node); } if ($this->hasChanged) { return $node; } return null; } private function processIf(If_ $if, int $key, StmtsAwareInterface $stmtsAware) : void { if ($if->elseifs !== []) { return; } // useless if () if (!$if->else instanceof Else_) { if ($this->hasNodeSideEffect($if->cond)) { return; } unset($stmtsAware->stmts[$key]); $this->hasChanged = \true; return; } $if->cond = $this->conditionInverter->createInvertedCondition($if->cond); $if->stmts = $if->else->stmts; $if->else = null; $this->hasChanged = \true; } /* * @param \PhpParser\Node\Stmt\For_\|\PhpParser\Node\Stmt\Foreach_ $for / private function processForForeach($for, int $key, StmtsAwareInterface $stmtsAware) : void { $stmts = (array) $stmtsAware->stmts; if ($for instanceof For_) { $variables = $this->betterNodeFinder->findInstanceOf(\array_merge($for->init, $for->cond, $for->loop), Variable::class); foreach ($variables as $variable) { if ($this->stmtsManipulator->isVariableUsedInNextStmt($stmts, $key + 1, (string) $this->getName($variable))) { return; } } unset($stmtsAware->stmts[$key]); $this->hasChanged = \true; return; } $exprs = \array_filter([$for->expr, $for->valueVar, $for->valueVar]); $variables = $this->betterNodeFinder->findInstanceOf($exprs, Variable::class); foreach ($variables as $variable) { if ($this->stmtsManipulator->isVariableUsedInNextStmt($stmts, $key + 1, (string) $this->getName($variable))) { return; } } unset($stmtsAware->stmts[$key]); $this->hasChanged = \true; } private function hasNodeSideEffect(Expr $expr) : bool { return $this->betterNodeFinder->hasInstancesOf($expr, [CallLike::class, Assign::class]); } } PK��6(\�u�� 0��Rector/Stmt/RemoveUnreachableStatementRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Stmt; use PhpParser\Node; use PhpParser\Node\Stmt; use Rector\Contract\PhpParser\Node\StmtsAwareInterface; use Rector\NodeAnalyzer\TerminatedNodeAnalyzer; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Stmt\RemoveUnreachableStatementRector\RemoveUnreachableStatementRectorTest / final class RemoveUnreachableStatementRector extends AbstractRector { /* * @readonly * @var \Rector\NodeAnalyzer\TerminatedNodeAnalyzer / private $terminatedNodeAnalyzer; public function __construct(TerminatedNodeAnalyzer $terminatedNodeAnalyzer) { $this->terminatedNodeAnalyzer = $terminatedNodeAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unreachable statements', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { return 5; $removeMe = 10; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { return 5; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [StmtsAwareInterface::class]; } /* * @param StmtsAwareInterface $node / public function refactor(Node $node) : ?Node { if ($node->stmts === null) { return null; } $originalStmts = $node->stmts; $cleanedStmts = $this->processCleanUpUnreachabelStmts($node, $node->stmts); if ($cleanedStmts === $originalStmts) { return null; } $node->stmts = $cleanedStmts; return $node; } /* * @param Stmt[] $stmts * @return Stmt[] / private function processCleanUpUnreachabelStmts(StmtsAwareInterface $stmtsAware, array $stmts) : array { foreach ($stmts as $key => $stmt) { if (!isset($stmts[$key - 1])) { continue; } $previousStmt = $stmts[$key - 1]; // unset... if ($this->terminatedNodeAnalyzer->isAlwaysTerminated($stmtsAware, $previousStmt, $stmt)) { \array_splice($stmts, $key); return $stmts; } } return $stmts; } } PK��6(\��/��0��Rector/Foreach_/RemoveUnusedForeachKeyRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Foreach_; use PhpParser\Node; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt\Foreach_; use PhpParser\NodeFinder; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\Contract\PhpParser\Node\StmtsAwareInterface; use Rector\NodeManipulator\StmtsManipulator; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Foreach_\RemoveUnusedForeachKeyRector\RemoveUnusedForeachKeyRectorTest / final class RemoveUnusedForeachKeyRector extends AbstractRector { /* * @readonly * @var \PhpParser\NodeFinder / private $nodeFinder; /* * @readonly * @var \Rector\NodeManipulator\StmtsManipulator / private $stmtsManipulator; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; public function __construct(NodeFinder $nodeFinder, StmtsManipulator $stmtsManipulator, PhpDocInfoFactory $phpDocInfoFactory, DocBlockUpdater $docBlockUpdater) { $this->nodeFinder = $nodeFinder; $this->stmtsManipulator = $stmtsManipulator; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->docBlockUpdater = $docBlockUpdater; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused key in foreach', [new CodeSample(<<<'CODE_SAMPLE' $items = []; foreach ($items as $key => $value) { $result = $value; } CODE_SAMPLE , <<<'CODE_SAMPLE' $items = []; foreach ($items as $value) { $result = $value; } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [StmtsAwareInterface::class]; } /* * @param StmtsAwareInterface $node / public function refactor(Node $node) : ?Node { if ($node->stmts === null) { return null; } $hasChanged = \false; foreach ($node->stmts as $key => $stmt) { if (!$stmt instanceof Foreach_) { continue; } if (!$stmt->keyVar instanceof Variable) { continue; } $keyVar = $stmt->keyVar; $isNodeUsed = (bool) $this->nodeFinder->findFirst($stmt->stmts, function (Node $node) use($keyVar) : bool { return $this->nodeComparator->areNodesEqual($node, $keyVar); }); if ($isNodeUsed) { continue; } $keyVarName = (string) $this->getName($keyVar); if ($this->stmtsManipulator->isVariableUsedInNextStmt($node, $key + 1, $keyVarName)) { continue; } $stmt->keyVar = null; $hasChanged = \true; $phpDocInfo = $this->phpDocInfoFactory->createFromNode($stmt); if (!$phpDocInfo instanceof PhpDocInfo) { continue; } $varTagValues = $phpDocInfo->getPhpDocNode()->getVarTagValues(); foreach ($varTagValues as $varTagValue) { $variableName = $varTagValue->variableName; if ($varTagValue->variableName === '$' . $keyVarName) { $phpDocInfo->removeByType(VarTagValueNode::class, $variableName); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($stmt); } } } if ($hasChanged) { return $node; } return null; } } PK��6(\��)��=��Rector/ClassLike/RemoveTypedPropertyNonMockDocblockRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassLike; use PhpParser\Node; use PhpParser\Node\Name\FullyQualified; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\Property; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode; use PHPStan\Type\ObjectType; use PHPStan\Type\UnionType; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\DeadCode\PhpDoc\TagRemover\VarTagRemover; use Rector\Enum\ClassName; use Rector\Rector\AbstractRector; use Rector\StaticTypeMapper\StaticTypeMapper; use Rector\ValueObject\PhpVersionFeature; use Rector\VersionBonding\Contract\MinPhpVersionInterface; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassLike\RemoveTypedPropertyNonMockDocblockRector\RemoveTypedPropertyNonMockDocblockRectorTest / final class RemoveTypedPropertyNonMockDocblockRector extends AbstractRector implements MinPhpVersionInterface { /* * @readonly * @var \Rector\DeadCode\PhpDoc\TagRemover\VarTagRemover / private $varTagRemover; /* * @readonly * @var \Rector\StaticTypeMapper\StaticTypeMapper / private $staticTypeMapper; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @var string / private const MOCK_OBJECT_CLASS = 'PHPUnit\\Framework\\MockObject\\MockObject'; public function __construct(VarTagRemover $varTagRemover, StaticTypeMapper $staticTypeMapper, PhpDocInfoFactory $phpDocInfoFactory) { $this->varTagRemover = $varTagRemover; $this->staticTypeMapper = $staticTypeMapper; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove @var annotation for PHPUnit\\Framework\\MockObject\\MockObject combined with native object type', [new CodeSample(<<<'CODE_SAMPLE' use PHPUnit\Framework\TestCase; use PHPUnit\Framework\MockObject\MockObject; final class SomeTest extends TestCase { /* * @var SomeClass\|MockObject / private SomeClass $someProperty; } CODE_SAMPLE , <<<'CODE_SAMPLE' use PHPUnit\Framework\TestCase; use PHPUnit\Framework\MockObject\MockObject; final class SomeTest extends TestCase { private SomeClass $someProperty; } CODE_SAMPLE )]); } public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Node { if (!$this->isObjectType($node, new ObjectType(ClassName::TEST_CASE_CLASS))) { return null; } $hasChanged = \false; foreach ($node->getProperties() as $property) { // not yet typed if (!$property->type instanceof Node) { continue; } if (\count($property->props) !== 1) { continue; } if (!$property->type instanceof FullyQualified) { continue; } if ($this->isObjectType($property->type, new ObjectType(self::MOCK_OBJECT_CLASS))) { continue; } $propertyDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($property); if (!$this->isVarTagUnionTypeMockObject($propertyDocInfo, $property)) { continue; } // clear var docblock if ($this->varTagRemover->removeVarTag($property)) { $hasChanged = \true; } } if (!$hasChanged) { return null; } return $node; } public function provideMinPhpVersion() : int { return PhpVersionFeature::TYPED_PROPERTIES; } private function isVarTagUnionTypeMockObject(PhpDocInfo $phpDocInfo, Property $property) : bool { $varTagValueNode = $phpDocInfo->getVarTagValueNode(); if (!$varTagValueNode instanceof VarTagValueNode) { return \false; } if (!$varTagValueNode->type instanceof UnionTypeNode) { return \false; } $varTagType = $this->staticTypeMapper->mapPHPStanPhpDocTypeNodeToPHPStanType($varTagValueNode->type, $property); if (!$varTagType instanceof UnionType) { return \false; } foreach ($varTagType->getTypes() as $unionedType) { if ($unionedType->isSuperTypeOf(new ObjectType(self::MOCK_OBJECT_CLASS))->yes()) { return \true; } } return \false; } } PK��6(\{�a$��$��+��Rector/ClassLike/RemoveAnnotationRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassLike; use PhpParser\Node; use PhpParser\Node\FunctionLike; use PhpParser\Node\Stmt\ClassConst; use PhpParser\Node\Stmt\ClassLike; use PhpParser\Node\Stmt\Property; use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\Contract\Rector\ConfigurableRectorInterface; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\ConfiguredCodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; use RectorPrefix202411\Webmozart\Assert\Assert; /* * @see \Rector\Tests\DeadCode\Rector\ClassLike\RemoveAnnotationRector\RemoveAnnotationRectorTest / final class RemoveAnnotationRector extends AbstractRector implements ConfigurableRectorInterface { /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover / private $phpDocTagRemover; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @var string[] / private $annotationsToRemove = []; public function __construct(PhpDocTagRemover $phpDocTagRemover, DocBlockUpdater $docBlockUpdater, PhpDocInfoFactory $phpDocInfoFactory) { $this->phpDocTagRemover = $phpDocTagRemover; $this->docBlockUpdater = $docBlockUpdater; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove annotation by names', [new ConfiguredCodeSample(<<<'CODE_SAMPLE' /* * @method getName() / final class SomeClass { } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { } CODE_SAMPLE , ['method'])]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassLike::class, FunctionLike::class, Property::class, ClassConst::class]; } /* * @param ClassLike\|FunctionLike\|Property\|ClassConst $node / public function refactor(Node $node) : ?Node { Assert::notEmpty($this->annotationsToRemove); $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node); if (!$phpDocInfo instanceof PhpDocInfo) { return null; } $hasChanged = \false; foreach ($this->annotationsToRemove as $annotationToRemove) { $namedHasChanged = $this->phpDocTagRemover->removeByName($phpDocInfo, $annotationToRemove); if ($namedHasChanged) { $hasChanged = \true; } if (!\is_a($annotationToRemove, PhpDocTagValueNode::class, \true)) { continue; } $typedHasChanged = $phpDocInfo->removeByType($annotationToRemove); if ($typedHasChanged) { $hasChanged = \true; } } if ($hasChanged) { $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); return $node; } return null; } /* * @param mixed[] $configuration / public function configure(array $configuration) : void { Assert::allString($configuration); $this->annotationsToRemove = $configuration; } } PK��6(\�[��2��Rector/Assign/RemoveUnusedVariableAssignRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Assign; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\AssignRef; use PhpParser\Node\Expr\Cast; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Expr\Include_; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Function_; use PHPStan\Analyser\Scope; use Rector\DeadCode\SideEffect\SideEffectNodeDetector; use Rector\NodeAnalyzer\VariableAnalyzer; use Rector\NodeManipulator\StmtsManipulator; use Rector\Php\ReservedKeywordAnalyzer; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Rector\AbstractScopeAwareRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Assign\RemoveUnusedVariableAssignRector\RemoveUnusedVariableAssignRectorTest / final class RemoveUnusedVariableAssignRector extends AbstractScopeAwareRector { /* * @readonly * @var \Rector\Php\ReservedKeywordAnalyzer / private $reservedKeywordAnalyzer; /* * @readonly * @var \Rector\DeadCode\SideEffect\SideEffectNodeDetector / private $sideEffectNodeDetector; /* * @readonly * @var \Rector\NodeAnalyzer\VariableAnalyzer / private $variableAnalyzer; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @readonly * @var \Rector\NodeManipulator\StmtsManipulator / private $stmtsManipulator; public function __construct(ReservedKeywordAnalyzer $reservedKeywordAnalyzer, SideEffectNodeDetector $sideEffectNodeDetector, VariableAnalyzer $variableAnalyzer, BetterNodeFinder $betterNodeFinder, StmtsManipulator $stmtsManipulator) { $this->reservedKeywordAnalyzer = $reservedKeywordAnalyzer; $this->sideEffectNodeDetector = $sideEffectNodeDetector; $this->variableAnalyzer = $variableAnalyzer; $this->betterNodeFinder = $betterNodeFinder; $this->stmtsManipulator = $stmtsManipulator; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused assigns to variables', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { $value = 5; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassMethod::class, Function_::class]; } /* * @param ClassMethod\|Function_ $node * @return null\|\PhpParser\Node\Stmt\ClassMethod\|\PhpParser\Node\Stmt\Function_ / public function refactorWithScope(Node $node, Scope $scope) { $stmts = $node->stmts; if ($stmts === null \|\| $stmts === []) { return null; } // we cannot be sure here if ($this->shouldSkip($stmts)) { return null; } $assignedVariableNamesByStmtPosition = $this->resolvedAssignedVariablesByStmtPosition($stmts); $hasChanged = \false; foreach ($assignedVariableNamesByStmtPosition as $stmtPosition => $variableName) { if ($this->stmtsManipulator->isVariableUsedInNextStmt($stmts, $stmtPosition + 1, $variableName)) { continue; } /* @var Expression<Assign> $currentStmt / $currentStmt = $stmts[$stmtPosition]; /* @var Assign $assign / $assign = $currentStmt->expr; if ($this->hasCallLikeInAssignExpr($assign, $scope)) { // clean safely $cleanAssignedExpr = $this->cleanCastedExpr($assign->expr); $newExpression = new Expression($cleanAssignedExpr); $this->mirrorComments($newExpression, $currentStmt); $node->stmts[$stmtPosition] = $newExpression; } else { unset($node->stmts[$stmtPosition]); } $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } private function cleanCastedExpr(Expr $expr) : Expr { if (!$expr instanceof Cast) { return $expr; } return $this->cleanCastedExpr($expr->expr); } private function hasCallLikeInAssignExpr(Expr $expr, Scope $scope) : bool { return (bool) $this->betterNodeFinder->findFirst($expr, function (Node $subNode) use($scope) : bool { return $this->sideEffectNodeDetector->detectCallExpr($subNode, $scope); }); } /* * @param Stmt[] $stmts / private function shouldSkip(array $stmts) : bool { return (bool) $this->betterNodeFinder->findFirst($stmts, function (Node $node) : bool { if ($node instanceof Include_) { return \true; } if (!$node instanceof FuncCall) { return \false; } return $this->isName($node, 'compact'); }); } /* * @param array<int, Stmt> $stmts * @return array<int, string> / private function resolvedAssignedVariablesByStmtPosition(array $stmts) : array { $assignedVariableNamesByStmtPosition = []; $refVariableNames = []; foreach ($stmts as $key => $stmt) { if (!$stmt instanceof Expression) { continue; } if ($stmt->expr instanceof AssignRef && $stmt->expr->var instanceof Variable) { $refVariableNames[] = (string) $this->getName($stmt->expr->var); } if (!$stmt->expr instanceof Assign) { continue; } $assign = $stmt->expr; if (!$assign->var instanceof Variable) { continue; } $variableName = $this->getName($assign->var); if (!\is_string($variableName)) { continue; } if ($this->reservedKeywordAnalyzer->isNativeVariable($variableName)) { continue; } if ($this->shouldSkipVariable($assign->var, $variableName, $refVariableNames)) { continue; } $assignedVariableNamesByStmtPosition[$key] = $variableName; } return $assignedVariableNamesByStmtPosition; } /* * @param string[] $refVariableNames / private function shouldSkipVariable(Variable $variable, string $variableName, array $refVariableNames) : bool { if ($this->variableAnalyzer->isStaticOrGlobal($variable)) { return \true; } if ($this->variableAnalyzer->isUsedByReference($variable)) { return \true; } return \in_array($variableName, $refVariableNames, \true); } } PK��6(\/��4[��[����Rector/Assign/RemoveDoubleAssignRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Assign; use PhpParser\Node; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\Closure; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\Function_; use PhpParser\Node\Stmt\If_; use PhpParser\Node\Stmt\Namespace_; use PHPStan\Analyser\Scope; use Rector\DeadCode\SideEffect\SideEffectNodeDetector; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\PhpParser\Node\CustomNode\FileWithoutNamespace; use Rector\Rector\AbstractScopeAwareRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /** * @see \Rector\Tests\DeadCode\Rector\Assign\RemoveDoubleAssignRector\RemoveDoubleAssignRectorTest / final class RemoveDoubleAssignRector extends AbstractScopeAwareRector { /* * @readonly * @var \Rector\DeadCode\SideEffect\SideEffectNodeDetector / private $sideEffectNodeDetector; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; public function __construct(SideEffectNodeDetector $sideEffectNodeDetector, BetterNodeFinder $betterNodeFinder) { $this->sideEffectNodeDetector = $sideEffectNodeDetector; $this->betterNodeFinder = $betterNodeFinder; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Simplify useless double assigns', [new CodeSample(<<<'CODE_SAMPLE' $value = 1; $value = 1; CODE_SAMPLE , '$value = 1;')]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Foreach_::class, FileWithoutNamespace::class, ClassMethod::class, Function_::class, Closure::class, If_::class, Namespace_::class]; } /* * @param Foreach_\|FileWithoutNamespace\|If_\|Namespace_\|ClassMethod\|Function_\|Closure $node / public function refactorWithScope(Node $node, Scope $scope) : ?Node { $stmts = $node->stmts; if ($stmts === null) { return null; } $hasChanged = \false; foreach ($stmts as $key => $stmt) { if (!isset($stmts[$key + 1])) { continue; } if (!$stmt instanceof Expression) { continue; } $nextStmt = $stmts[$key + 1]; if (!$nextStmt instanceof Expression) { continue; } if (!$stmt->expr instanceof Assign) { continue; } if (!$nextStmt->expr instanceof Assign) { continue; } $nextAssign = $nextStmt->expr; if (!$this->nodeComparator->areNodesEqual($nextAssign->var, $stmt->expr->var)) { continue; } // early check self referencing, ensure that variable not re-used if ($this->isSelfReferencing($nextAssign)) { continue; } // detect call expression has side effect // no calls on right, could hide e.g. array_pop()\|array_shift() if ($this->sideEffectNodeDetector->detectCallExpr($stmt->expr->expr, $scope)) { continue; } if (!$stmt->expr->var instanceof Variable && !$stmt->expr->var instanceof PropertyFetch && !$stmt->expr->var instanceof StaticPropertyFetch) { continue; } // remove current Stmt if will be overriden in next stmt unset($node->stmts[$key]); $hasChanged = \true; } if (!$hasChanged) { return null; } return $node; } private function isSelfReferencing(Assign $assign) : bool { return (bool) $this->betterNodeFinder->findFirst($assign->expr, function (Node $subNode) use($assign) : bool { return $this->nodeComparator->areNodesEqual($assign->var, $subNode); }); } } PK��6(\5 Ɵv��v��,��Rector/Concat/RemoveConcatAutocastRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Concat; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\BinaryOp\Concat; use PhpParser\Node\Expr\Cast\String_; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Concat\RemoveConcatAutocastRector\RemoveConcatAutocastRectorTest / final class RemoveConcatAutocastRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove (string) casting when it comes to concat, that does this by default', [new CodeSample(<<<'CODE_SAMPLE' class SomeConcatingClass { public function run($value) { return 'hi ' . (string) $value; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeConcatingClass { public function run($value) { return 'hi ' . $value; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Concat::class]; } /* * @param Concat $node / public function refactor(Node $node) : ?Node { if (!$node->left instanceof String_ && !$node->right instanceof String_) { return null; } $node->left = $this->removeStringCast($node->left); $node->right = $this->removeStringCast($node->right); return $node; } private function removeStringCast(Expr $expr) : Expr { return $expr instanceof String_ ? $expr->expr : $expr; } } PK��6(\�E��B��Rector/PropertyProperty/RemoveNullPropertyInitializationRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\PropertyProperty; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\ConstFetch; use PhpParser\Node\Stmt\Property; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; use function strtolower; /* * @see \Rector\Tests\DeadCode\Rector\PropertyProperty\RemoveNullPropertyInitializationRector\RemoveNullPropertyInitializationRectorTest / final class RemoveNullPropertyInitializationRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove initialization with null value from property declarations', [new CodeSample(<<<'CODE_SAMPLE' class SunshineCommand extends ParentClassWithNewConstructor { private $myVar = null; } CODE_SAMPLE , <<<'CODE_SAMPLE' class SunshineCommand extends ParentClassWithNewConstructor { private $myVar; } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Property::class]; } /* * @param Property $node / public function refactor(Node $node) : ?Node { if ($node->type instanceof Node) { return null; } $hasChanged = \false; foreach ($node->props as $prop) { $defaultValueNode = $prop->default; if (!$defaultValueNode instanceof Expr) { continue; } if (!$defaultValueNode instanceof ConstFetch) { continue; } if (strtolower((string) $defaultValueNode->name) !== 'null') { continue; } $prop->default = null; $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } } PK��6(\f׵��3��Rector/ClassMethod/RemoveEmptyClassMethodRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Name\FullyQualified; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PHPStan\PhpDocParser\Ast\PhpDoc\DeprecatedTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\DeadCode\NodeManipulator\ControllerClassMethodManipulator; use Rector\NodeAnalyzer\ParamAnalyzer; use Rector\NodeManipulator\ClassMethodManipulator; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Rector\AbstractRector; use Rector\ValueObject\MethodName; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveEmptyClassMethodRector\RemoveEmptyClassMethodRectorTest / final class RemoveEmptyClassMethodRector extends AbstractRector { /* * @readonly * @var \Rector\NodeManipulator\ClassMethodManipulator / private $classMethodManipulator; /* * @readonly * @var \Rector\DeadCode\NodeManipulator\ControllerClassMethodManipulator / private $controllerClassMethodManipulator; /* * @readonly * @var \Rector\NodeAnalyzer\ParamAnalyzer / private $paramAnalyzer; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; public function __construct(ClassMethodManipulator $classMethodManipulator, ControllerClassMethodManipulator $controllerClassMethodManipulator, ParamAnalyzer $paramAnalyzer, PhpDocInfoFactory $phpDocInfoFactory, BetterNodeFinder $betterNodeFinder) { $this->classMethodManipulator = $classMethodManipulator; $this->controllerClassMethodManipulator = $controllerClassMethodManipulator; $this->paramAnalyzer = $paramAnalyzer; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->betterNodeFinder = $betterNodeFinder; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove empty class methods not required by parents', [new CodeSample(<<<'CODE_SAMPLE' class OrphanClass { public function __construct() { } } CODE_SAMPLE , <<<'CODE_SAMPLE' class OrphanClass { } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Class_ { $hasChanged = \false; foreach ($node->stmts as $key => $stmt) { if (!$stmt instanceof ClassMethod) { continue; } if ($stmt->stmts !== null && $stmt->stmts !== []) { continue; } if ($stmt->isAbstract()) { continue; } if ($stmt->isFinal() && !$node->isFinal()) { continue; } if ($this->shouldSkipNonFinalNonPrivateClassMethod($node, $stmt)) { continue; } if ($this->shouldSkipClassMethod($node, $stmt)) { continue; } unset($node->stmts[$key]); $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } private function shouldSkipNonFinalNonPrivateClassMethod(Class_ $class, ClassMethod $classMethod) : bool { if ($class->isFinal()) { return \false; } if ($classMethod->isMagic()) { return \false; } if ($classMethod->isProtected()) { return \true; } return $classMethod->isPublic(); } private function shouldSkipClassMethod(Class_ $class, ClassMethod $classMethod) : bool { $desiredClassMethodName = $this->getName($classMethod); // is method called somewhere else in the class? foreach ($class->getMethods() as $anotherClassMethod) { if ($anotherClassMethod === $classMethod) { continue; } if ($this->containsMethodCall($anotherClassMethod, $desiredClassMethodName)) { return \true; } } if ($this->classMethodManipulator->isNamedConstructor($classMethod)) { return \true; } if ($this->classMethodManipulator->hasParentMethodOrInterfaceMethod($class, $classMethod->name->toString())) { return \true; } if ($this->paramAnalyzer->hasPropertyPromotion($classMethod->params)) { return \true; } if ($this->hasDeprecatedAnnotation($classMethod)) { return \true; } if ($this->controllerClassMethodManipulator->isControllerClassMethod($class, $classMethod)) { return \true; } if ($this->nodeNameResolver->isName($classMethod, MethodName::CONSTRUCT)) { // has parent class? return $class->extends instanceof FullyQualified; } return $this->nodeNameResolver->isName($classMethod, MethodName::INVOKE); } private function hasDeprecatedAnnotation(ClassMethod $classMethod) : bool { $phpDocInfo = $this->phpDocInfoFactory->createFromNode($classMethod); if (!$phpDocInfo instanceof PhpDocInfo) { return \false; } return $phpDocInfo->hasByType(DeprecatedTagValueNode::class); } private function containsMethodCall(ClassMethod $anotherClassMethod, string $desiredClassMethodName) : bool { return (bool) $this->betterNodeFinder->findFirst($anotherClassMethod, function (Node $node) use($desiredClassMethodName) : bool { if (!$node instanceof MethodCall) { return \false; } if (!$node->var instanceof Variable) { return \false; } if (!$this->isName($node->var, 'this')) { return \false; } return $this->isName($node->name, $desiredClassMethodName); }); } } PK��6(\m�=��>��Rector/ClassMethod/RemoveUnusedPublicMethodParameterRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Name\FullyQualified; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use Rector\DeadCode\NodeManipulator\ClassMethodParamRemover; use Rector\DeadCode\NodeManipulator\VariadicFunctionLikeDetector; use Rector\NodeAnalyzer\MagicClassMethodAnalyzer; use Rector\Php80\NodeAnalyzer\PhpAttributeAnalyzer; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUnusedPublicMethodParameterRector\RemoveUnusedPublicMethodParameterRectorTest / final class RemoveUnusedPublicMethodParameterRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\NodeManipulator\VariadicFunctionLikeDetector / private $variadicFunctionLikeDetector; /* * @readonly * @var \Rector\DeadCode\NodeManipulator\ClassMethodParamRemover / private $classMethodParamRemover; /* * @readonly * @var \Rector\NodeAnalyzer\MagicClassMethodAnalyzer / private $magicClassMethodAnalyzer; /* * @readonly * @var \Rector\Php80\NodeAnalyzer\PhpAttributeAnalyzer / private $phpAttributeAnalyzer; public function __construct(VariadicFunctionLikeDetector $variadicFunctionLikeDetector, ClassMethodParamRemover $classMethodParamRemover, MagicClassMethodAnalyzer $magicClassMethodAnalyzer, PhpAttributeAnalyzer $phpAttributeAnalyzer) { $this->variadicFunctionLikeDetector = $variadicFunctionLikeDetector; $this->classMethodParamRemover = $classMethodParamRemover; $this->magicClassMethodAnalyzer = $magicClassMethodAnalyzer; $this->phpAttributeAnalyzer = $phpAttributeAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused parameter in public method on final class without extends and interface', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { public function run($a, $b) { echo $a; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { public function run($a) { echo $a; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Node { // may have child, or override parent that needs to follow the signature if (!$node->isFinal() \|\| $node->extends instanceof FullyQualified \|\| $node->implements !== []) { return null; } $hasChanged = \false; foreach ($node->getMethods() as $classMethod) { if ($this->shouldSkipClassMethod($classMethod, $node)) { continue; } $changedMethod = $this->classMethodParamRemover->processRemoveParams($classMethod); if (!$changedMethod instanceof ClassMethod) { continue; } $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } private function shouldSkipClassMethod(ClassMethod $classMethod, Class_ $class) : bool { // private method is handled by different rule if (!$classMethod->isPublic()) { return \true; } if ($classMethod->params === []) { return \true; } // parameter is required for contract coupling if ($this->isName($classMethod->name, '__invoke') && $this->phpAttributeAnalyzer->hasPhpAttribute($class, 'Symfony\\Component\\Messenger\\Attribute\\AsMessageHandler')) { return \true; } if ($this->magicClassMethodAnalyzer->isUnsafeOverridden($classMethod)) { return \true; } return $this->variadicFunctionLikeDetector->isVariadic($classMethod); } } PK��6(\z�� 3��Rector/ClassMethod/RemoveUselessReturnTagRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Function_; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\DeadCode\PhpDoc\TagRemover\ReturnTagRemover; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUselessReturnTagRector\RemoveUselessReturnTagRectorTest / final class RemoveUselessReturnTagRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\PhpDoc\TagRemover\ReturnTagRemover / private $returnTagRemover; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(ReturnTagRemover $returnTagRemover, DocBlockUpdater $docBlockUpdater, PhpDocInfoFactory $phpDocInfoFactory) { $this->returnTagRemover = $returnTagRemover; $this->docBlockUpdater = $docBlockUpdater; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove @return docblock with same type as defined in PHP', [new CodeSample(<<<'CODE_SAMPLE' use stdClass; class SomeClass { /* * @return stdClass / public function foo(): stdClass { } } CODE_SAMPLE , <<<'CODE_SAMPLE' use stdClass; class SomeClass { public function foo(): stdClass { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassMethod::class, Function_::class]; } /* * @param ClassMethod\|Function_ $node / public function refactor(Node $node) : ?Node { $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $hasChanged = $this->returnTagRemover->removeReturnTagIfUseless($phpDocInfo, $node); if (!$hasChanged) { return null; } $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); return $node; } } PK��6(\13]��6��Rector/ClassMethod/RemoveUnusedPrivateMethodRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PHPStan\Analyser\Scope; use PHPStan\Reflection\ClassReflection; use Rector\DeadCode\NodeAnalyzer\IsClassMethodUsedAnalyzer; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Rector\AbstractScopeAwareRector; use Rector\Reflection\ReflectionResolver; use Rector\ValueObject\MethodName; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUnusedPrivateMethodRector\RemoveUnusedPrivateMethodRectorTest / final class RemoveUnusedPrivateMethodRector extends AbstractScopeAwareRector { /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\IsClassMethodUsedAnalyzer / private $isClassMethodUsedAnalyzer; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; public function __construct(IsClassMethodUsedAnalyzer $isClassMethodUsedAnalyzer, ReflectionResolver $reflectionResolver, BetterNodeFinder $betterNodeFinder) { $this->isClassMethodUsedAnalyzer = $isClassMethodUsedAnalyzer; $this->reflectionResolver = $reflectionResolver; $this->betterNodeFinder = $betterNodeFinder; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused private method', [new CodeSample(<<<'CODE_SAMPLE' final class SomeController { public function run() { return 5; } private function skip() { return 10; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeController { public function run() { return 5; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactorWithScope(Node $node, Scope $scope) : ?Node { $classMethods = $node->getMethods(); if ($classMethods === []) { return null; } $filter = static function (ClassMethod $classMethod) : bool { return $classMethod->isPrivate(); }; $privateMethods = \array_filter($classMethods, $filter); if ($privateMethods === []) { return null; } if ($this->hasDynamicMethodCallOnFetchThis($classMethods)) { return null; } $hasChanged = \false; $classReflection = $this->reflectionResolver->resolveClassReflection($node); foreach ($privateMethods as $privateMethod) { if ($this->shouldSkip($privateMethod, $classReflection)) { continue; } if ($this->isClassMethodUsedAnalyzer->isClassMethodUsed($node, $privateMethod, $scope)) { continue; } unset($node->stmts[$privateMethod->getAttribute(AttributeKey::STMT_KEY)]); $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } private function shouldSkip(ClassMethod $classMethod, ?ClassReflection $classReflection) : bool { if (!$classReflection instanceof ClassReflection) { return \true; } // unreliable to detect trait, interface, anonymous class: doesn't make sense if ($classReflection->isTrait()) { return \true; } if ($classReflection->isInterface()) { return \true; } if ($classReflection->isAnonymous()) { return \true; } // skip magic methods - @see https://www.php.net/manual/en/language.oop5.magic.php if ($classMethod->isMagic()) { return \true; } return $classReflection->hasMethod(MethodName::CALL); } /* * @param ClassMethod[] $classMethods / private function hasDynamicMethodCallOnFetchThis(array $classMethods) : bool { foreach ($classMethods as $classMethod) { $isFound = (bool) $this->betterNodeFinder->findFirst((array) $classMethod->getStmts(), function (Node $subNode) : bool { if (!$subNode instanceof MethodCall) { return \false; } if (!$subNode->var instanceof Variable) { return \false; } if (!$this->nodeNameResolver->isName($subNode->var, 'this')) { return \false; } return $subNode->name instanceof Variable; }); if ($isFound) { return \true; } } return \false; } } PK��6(\��(��9��Rector/ClassMethod/RemoveUnusedConstructorParamRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PHPStan\Reflection\ClassReflection; use Rector\DeadCode\NodeManipulator\ClassMethodParamRemover; use Rector\NodeAnalyzer\ParamAnalyzer; use Rector\Rector\AbstractRector; use Rector\Reflection\ReflectionResolver; use Rector\ValueObject\MethodName; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUnusedConstructorParamRector\RemoveUnusedConstructorParamRectorTest / final class RemoveUnusedConstructorParamRector extends AbstractRector { /* * @readonly * @var \Rector\NodeAnalyzer\ParamAnalyzer / private $paramAnalyzer; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\DeadCode\NodeManipulator\ClassMethodParamRemover / private $classMethodParamRemover; public function __construct(ParamAnalyzer $paramAnalyzer, ReflectionResolver $reflectionResolver, ClassMethodParamRemover $classMethodParamRemover) { $this->paramAnalyzer = $paramAnalyzer; $this->reflectionResolver = $reflectionResolver; $this->classMethodParamRemover = $classMethodParamRemover; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused parameter in constructor', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { private $hey; public function __construct($hey, $man) { $this->hey = $hey; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { private $hey; public function __construct($hey) { $this->hey = $hey; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Node { $constructorClassMethod = $node->getMethod(MethodName::CONSTRUCT); if (!$constructorClassMethod instanceof ClassMethod) { return null; } if ($constructorClassMethod->params === []) { return null; } if ($this->paramAnalyzer->hasPropertyPromotion($constructorClassMethod->params)) { return null; } if ($constructorClassMethod->isAbstract()) { return null; } $classReflection = $this->reflectionResolver->resolveClassReflection($node); if (!$classReflection instanceof ClassReflection) { return null; } $interfaces = $classReflection->getInterfaces(); foreach ($interfaces as $interface) { if ($interface->hasNativeMethod(MethodName::CONSTRUCT)) { return null; } } $changedConstructorClassMethod = $this->classMethodParamRemover->processRemoveParams($constructorClassMethod); if (!$changedConstructorClassMethod instanceof ClassMethod) { return null; } return $node; } } PK��6(\X�4��?��Rector/ClassMethod/RemoveUselessReturnExprInConstructRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Closure; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Function_; use PhpParser\Node\Stmt\Return_; use PhpParser\NodeTraverser; use Rector\NodeAnalyzer\ExprAnalyzer; use Rector\Rector\AbstractRector; use Rector\ValueObject\MethodName; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUselessReturnExprInConstructRector\RemoveUselessReturnExprInConstructRectorTest / final class RemoveUselessReturnExprInConstructRector extends AbstractRector { /* * @readonly * @var \Rector\NodeAnalyzer\ExprAnalyzer / private $exprAnalyzer; public function __construct(ExprAnalyzer $exprAnalyzer) { $this->exprAnalyzer = $exprAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove useless return Expr in __construct()', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function __construct() { if (rand(0, 1)) { $this->init(); return true; } if (rand(2, 3)) { return parent::construct(); } $this->execute(); } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function __construct() { if (rand(0, 1)) { $this->init(); return; } if (rand(2, 3)) { parent::construct(); return; } $this->execute(); } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassMethod::class]; } /* * @param ClassMethod $node / public function refactor(Node $node) : ?Node { if ($node->stmts === null) { return null; } if (!$this->isName($node, MethodName::CONSTRUCT)) { return null; } $hasChanged = \false; $this->traverseNodesWithCallable($node->stmts, function (Node $subNode) use(&$hasChanged) { if ($subNode instanceof Class_ \|\| $subNode instanceof Function_ \|\| $subNode instanceof Closure) { return NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN; } if (!$subNode instanceof Return_) { return null; } if (!$subNode->expr instanceof Expr) { return null; } $hasChanged = \true; if ($this->exprAnalyzer->isDynamicExpr($subNode->expr)) { return [new Expression($subNode->expr), new Return_()]; } $subNode->expr = null; return $subNode; }); if ($hasChanged) { return $node; } return null; } } PK��6(\�?4P��9��Rector/ClassMethod/RemoveUnusedPromotedPropertyRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\TraitUse; use PHPStan\Analyser\Scope; use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode; use PHPStan\Reflection\ClassReflection; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\DeadCode\NodeAnalyzer\PropertyWriteonlyAnalyzer; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\PhpParser\NodeFinder\PropertyFetchFinder; use Rector\Privatization\NodeManipulator\VisibilityManipulator; use Rector\Rector\AbstractScopeAwareRector; use Rector\Reflection\ReflectionResolver; use Rector\ValueObject\MethodName; use Rector\ValueObject\PhpVersionFeature; use Rector\ValueObject\Visibility; use Rector\VersionBonding\Contract\MinPhpVersionInterface; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUnusedPromotedPropertyRector\RemoveUnusedPromotedPropertyRectorTest / final class RemoveUnusedPromotedPropertyRector extends AbstractScopeAwareRector implements MinPhpVersionInterface { /* * @readonly * @var \Rector\PhpParser\NodeFinder\PropertyFetchFinder / private $propertyFetchFinder; /* * @readonly * @var \Rector\Privatization\NodeManipulator\VisibilityManipulator / private $visibilityManipulator; /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\PropertyWriteonlyAnalyzer / private $propertyWriteonlyAnalyzer; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover / private $phpDocTagRemover; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; public function __construct(PropertyFetchFinder $propertyFetchFinder, VisibilityManipulator $visibilityManipulator, PropertyWriteonlyAnalyzer $propertyWriteonlyAnalyzer, BetterNodeFinder $betterNodeFinder, ReflectionResolver $reflectionResolver, PhpDocInfoFactory $phpDocInfoFactory, PhpDocTagRemover $phpDocTagRemover, DocBlockUpdater $docBlockUpdater) { $this->propertyFetchFinder = $propertyFetchFinder; $this->visibilityManipulator = $visibilityManipulator; $this->propertyWriteonlyAnalyzer = $propertyWriteonlyAnalyzer; $this->betterNodeFinder = $betterNodeFinder; $this->reflectionResolver = $reflectionResolver; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->phpDocTagRemover = $phpDocTagRemover; $this->docBlockUpdater = $docBlockUpdater; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused promoted property', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function __construct( private $someUnusedDependency, private $usedDependency ) { } public function getUsedDependency() { return $this->usedDependency; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function __construct( private $usedDependency ) { } public function getUsedDependency() { return $this->usedDependency; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactorWithScope(Node $node, Scope $scope) : ?Node { $constructClassMethod = $node->getMethod(MethodName::CONSTRUCT); if (!$constructClassMethod instanceof ClassMethod) { return null; } if ($constructClassMethod->params === []) { return null; } if ($this->shouldSkipClass($node)) { return null; } $hasChanged = \false; $phpDocInfo = $this->phpDocInfoFactory->createFromNode($constructClassMethod); foreach ($constructClassMethod->params as $key => $param) { // only private local scope; removing public property might be dangerous if (!$this->visibilityManipulator->hasVisibility($param, Visibility::PRIVATE)) { continue; } $paramName = $this->getName($param); $propertyFetches = $this->propertyFetchFinder->findLocalPropertyFetchesByName($node, $paramName); if ($propertyFetches !== []) { continue; } if (!$this->propertyWriteonlyAnalyzer->arePropertyFetchesExclusivelyBeingAssignedTo($propertyFetches)) { continue; } // always changed on below code $hasChanged = \true; // is variable used? only remove property, keep param $variable = $this->betterNodeFinder->findVariableOfName((array) $constructClassMethod->stmts, $paramName); if ($variable instanceof Variable) { $param->flags = 0; continue; } if ($phpDocInfo instanceof PhpDocInfo) { $paramTagValueNode = $phpDocInfo->getParamTagValueByName($paramName); if ($paramTagValueNode instanceof ParamTagValueNode) { $this->phpDocTagRemover->removeTagValueFromNode($phpDocInfo, $paramTagValueNode); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($constructClassMethod); } } // remove param unset($constructClassMethod->params[$key]); } if ($hasChanged) { return $node; } return null; } public function provideMinPhpVersion() : int { return PhpVersionFeature::PROPERTY_PROMOTION; } private function shouldSkipClass(Class_ $class) : bool { if ($class->attrGroups !== []) { return \true; } $magicGetMethod = $class->getMethod(MethodName::__GET); if ($magicGetMethod instanceof ClassMethod) { return \true; } foreach ($class->stmts as $stmt) { if ($stmt instanceof TraitUse) { return \true; } } $classReflection = $this->reflectionResolver->resolveClassReflection($class); if ($classReflection instanceof ClassReflection) { $interfaces = $classReflection->getInterfaces(); foreach ($interfaces as $interface) { if ($interface->hasNativeMethod(MethodName::CONSTRUCT)) { return \true; } } } return \false; } } PK��6(\�� 2��Rector/ClassMethod/RemoveUselessParamTagRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Function_; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\DeadCode\PhpDoc\TagRemover\ParamTagRemover; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUselessParamTagRector\RemoveUselessParamTagRectorTest / final class RemoveUselessParamTagRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\PhpDoc\TagRemover\ParamTagRemover / private $paramTagRemover; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(ParamTagRemover $paramTagRemover, PhpDocInfoFactory $phpDocInfoFactory) { $this->paramTagRemover = $paramTagRemover; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove @param docblock with same type as parameter type', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { /* * @param string $a * @param string $b description / public function foo(string $a, string $b) { } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { /* * @param string $b description / public function foo(string $a, string $b) { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassMethod::class, Function_::class]; } /* * @param ClassMethod\|Function_ $node / public function refactor(Node $node) : ?Node { $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node); if (!$phpDocInfo instanceof PhpDocInfo) { return null; } $hasChanged = $this->paramTagRemover->removeParamTagsIfUseless($phpDocInfo, $node); if ($hasChanged) { return $node; } return null; } } PK��6(\��KXE��E��?��Rector/ClassMethod/RemoveUnusedPrivateMethodParameterRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Param; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\ClassMethod; use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\DeadCode\NodeCollector\UnusedParameterResolver; use Rector\DeadCode\NodeManipulator\VariadicFunctionLikeDetector; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUnusedPrivateMethodParameterRector\RemoveUnusedPrivateMethodParameterRectorTest / final class RemoveUnusedPrivateMethodParameterRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\NodeManipulator\VariadicFunctionLikeDetector / private $variadicFunctionLikeDetector; /* * @readonly * @var \Rector\DeadCode\NodeCollector\UnusedParameterResolver / private $unusedParameterResolver; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover / private $phpDocTagRemover; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; public function __construct(VariadicFunctionLikeDetector $variadicFunctionLikeDetector, UnusedParameterResolver $unusedParameterResolver, PhpDocTagRemover $phpDocTagRemover, DocBlockUpdater $docBlockUpdater, PhpDocInfoFactory $phpDocInfoFactory, BetterNodeFinder $betterNodeFinder) { $this->variadicFunctionLikeDetector = $variadicFunctionLikeDetector; $this->unusedParameterResolver = $unusedParameterResolver; $this->phpDocTagRemover = $phpDocTagRemover; $this->docBlockUpdater = $docBlockUpdater; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->betterNodeFinder = $betterNodeFinder; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused parameter, if not required by interface or parent class', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { private function run($value, $value2) { $this->value = $value; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { private function run($value) { $this->value = $value; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Node { $hasChanged = \false; foreach ($node->getMethods() as $classMethod) { if ($this->shouldSkipClassMethod($classMethod)) { continue; } $unusedParameters = $this->unusedParameterResolver->resolve($classMethod); if ($unusedParameters === []) { continue; } $unusedParameterPositions = \array_keys($unusedParameters); foreach (\array_keys($classMethod->params) as $key) { if (!\in_array($key, $unusedParameterPositions, \true)) { continue; } unset($classMethod->params[$key]); } // reset param keys $classMethod->params = \array_values($classMethod->params); $this->clearPhpDocInfo($classMethod, $unusedParameters); $this->removeCallerArgs($node, $classMethod, $unusedParameters); $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } /* * @param Param[] $unusedParameters / private function removeCallerArgs(Class_ $class, ClassMethod $classMethod, array $unusedParameters) : void { $classMethods = $class->getMethods(); if ($classMethods === []) { return; } $methodName = $this->nodeNameResolver->getName($classMethod); $keysArg = \array_keys($unusedParameters); foreach ($classMethods as $classMethod) { /* @var MethodCall[] $callers / $callers = $this->resolveCallers($classMethod, $methodName); if ($callers === []) { continue; } foreach ($callers as $caller) { $this->cleanupArgs($caller, $keysArg); } } } /* * @param int[] $keysArg / private function cleanupArgs(MethodCall $methodCall, array $keysArg) : void { if ($methodCall->isFirstClassCallable()) { return; } $args = $methodCall->getArgs(); foreach (\array_keys($args) as $key) { if (\in_array($key, $keysArg, \true)) { unset($args[$key]); } } // reset arg keys $methodCall->args = \array_values($args); } /* * @return MethodCall[] / private function resolveCallers(ClassMethod $classMethod, string $methodName) : array { return $this->betterNodeFinder->find($classMethod, function (Node $subNode) use($methodName) : bool { if (!$subNode instanceof MethodCall) { return \false; } if ($subNode->isFirstClassCallable()) { return \false; } if (!$subNode->var instanceof Variable) { return \false; } if (!$this->nodeNameResolver->isName($subNode->var, 'this')) { return \false; } return $this->nodeNameResolver->isName($subNode->name, $methodName); }); } private function shouldSkipClassMethod(ClassMethod $classMethod) : bool { if (!$classMethod->isPrivate()) { return \true; } if ($classMethod->params === []) { return \true; } return $this->variadicFunctionLikeDetector->isVariadic($classMethod); } /* * @param Param[] $unusedParameters / private function clearPhpDocInfo(ClassMethod $classMethod, array $unusedParameters) : void { $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($classMethod); $hasChanged = \false; foreach ($unusedParameters as $unusedParameter) { $parameterName = $this->getName($unusedParameter->var); if ($parameterName === null) { continue; } $paramTagValueNode = $phpDocInfo->getParamTagValueByName($parameterName); if (!$paramTagValueNode instanceof ParamTagValueNode) { continue; } if ($paramTagValueNode->parameterName !== '$' . $parameterName) { continue; } $hasTagRemoved = $this->phpDocTagRemover->removeTagValueFromNode($phpDocInfo, $paramTagValueNode); if ($hasTagRemoved) { $hasChanged = \true; } } if ($hasChanged) { $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($classMethod); } } } PK��6(\�M��3��Rector/ClassMethod/RemoveNullTagValueNodeRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\ClassMethod; use PhpParser\Node; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Function_; use PhpParser\Node\Stmt\Property; use PHPStan\PhpDocParser\Ast\Node as AstNode; use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode; use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode; use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\PhpDocParser\PhpDocParser\PhpDocNodeTraverser; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\ClassMethod\RemoveNullTagValueNodeRector\RemoveNullTagValueNodeRectorTest / final class RemoveNullTagValueNodeRector extends AbstractRector { /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(DocBlockUpdater $docBlockUpdater, PhpDocInfoFactory $phpDocInfoFactory) { $this->docBlockUpdater = $docBlockUpdater; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove @var/@param/@return null docblock', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { /* * @return null / public function foo() { return null; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function foo() { return null; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassMethod::class, Function_::class, Expression::class, Property::class]; } /* * @param ClassMethod\|Function_\|Expression\|Property $node / public function refactor(Node $node) : ?Node { if ($node instanceof Expression \|\| $node instanceof Property) { return $this->processVarTagNull($node); } $phpdocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $removedParamNames = []; foreach ($node->params as $param) { $paramName = $this->getName($param); $paramTagValueNode = $phpdocInfo->getParamTagValueByName($paramName); if ($paramTagValueNode instanceof ParamTagValueNode && $this->isNull($paramTagValueNode)) { $removedParamNames[] = $paramTagValueNode->parameterName; } } $hasRemoved = \false; if ($removedParamNames !== []) { $this->removeParamNullTag($phpdocInfo, $removedParamNames); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); $hasRemoved = \true; } $returnTagValueNode = $phpdocInfo->getReturnTagValue(); if ($returnTagValueNode instanceof ReturnTagValueNode && $this->isNull($returnTagValueNode)) { $phpdocInfo->removeByType(ReturnTagValueNode::class); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); $hasRemoved = \true; } if (!$hasRemoved) { return null; } return $node; } /* * @param \PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode\|\PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode\|\PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode $tag / private function isNull($tag) : bool { return $tag->type instanceof IdentifierTypeNode && $tag->type->__toString() === 'null' && $tag->description === ''; } /* * @param string[] $paramNames / private function removeParamNullTag(PhpDocInfo $phpDocInfo, array $paramNames) : void { $phpDocNodeTraverser = new PhpDocNodeTraverser(); $phpDocNodeTraverser->traverseWithCallable($phpDocInfo->getPhpDocNode(), '', static function (AstNode $astNode) use($paramNames) : ?int { if (!$astNode instanceof PhpDocTagNode) { return null; } if (!$astNode->value instanceof ParamTagValueNode) { return null; } if (\in_array($astNode->value->parameterName, $paramNames, \true)) { return PhpDocNodeTraverser::NODE_REMOVE; } return null; }); } /* * @param \PhpParser\Node\Stmt\Expression\|\PhpParser\Node\Stmt\Property $node / private function processVarTagNull($node) : ?Node { $phpdocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $varTagValueNode = $phpdocInfo->getVarTagValueNode(); if ($varTagValueNode instanceof VarTagValueNode && $this->isNull($varTagValueNode)) { $phpdocInfo->removeByType(VarTagValueNode::class); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); return $node; } return null; } } PK��6(\f�\|D� �� ,��Rector/TryCatch/RemoveDeadTryCatchRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\TryCatch; use PhpParser\Node; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Finally_; use PhpParser\Node\Stmt\Nop; use PhpParser\Node\Stmt\Throw_; use PhpParser\Node\Stmt\TryCatch; use PhpParser\NodeTraverser; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\TryCatch\RemoveDeadTryCatchRector\RemoveDeadTryCatchRectorTest / final class RemoveDeadTryCatchRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove dead try/catch', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { try { // some code } catch (Throwable $throwable) { throw $throwable; } } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [TryCatch::class]; } /* * @param TryCatch $node * @return Stmt[]\|null\|TryCatch\|int / public function refactor(Node $node) { $isEmptyFinallyStmts = !$node->finally instanceof Finally_ \|\| $this->isEmpty($node->finally->stmts); // not empty stmts on finally always executed if (!$isEmptyFinallyStmts) { return null; } if ($this->isEmpty($node->stmts)) { return NodeTraverser::REMOVE_NODE; } if (\count($node->catches) !== 1) { return null; } $onlyCatch = $node->catches[0]; if ($this->isEmpty($onlyCatch->stmts)) { return null; } $onlyCatchStmt = $onlyCatch->stmts[0]; if (!$onlyCatchStmt instanceof Throw_) { return null; } if (!$this->nodeComparator->areNodesEqual($onlyCatch->var, $onlyCatchStmt->expr)) { return null; } return $node->stmts; } /* * @param Stmt[] $stmts / private function isEmpty(array $stmts) : bool { if ($stmts === []) { return \true; } if (\count($stmts) > 1) { return \false; } return $stmts[0] instanceof Nop; } } PK��6(\Y��$[��[��<��Rector/Ternary/TernaryToBooleanOrFalseToBooleanAndRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Ternary; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use PhpParser\Node\Expr\Ternary; use Rector\PhpParser\Node\Value\ValueResolver; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Ternary\TernaryToBooleanOrFalseToBooleanAndRector\TernaryToBooleanOrFalseToBooleanAndRectorTest / final class TernaryToBooleanOrFalseToBooleanAndRector extends AbstractRector { /* * @readonly * @var \Rector\PhpParser\Node\Value\ValueResolver / private $valueResolver; public function __construct(ValueResolver $valueResolver) { $this->valueResolver = $valueResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Change ternary of bool : false to && bool', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function go() { return $value ? $this->getBool() : false; } private function getBool(): bool { return (bool) 5; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function go() { return $value && $this->getBool(); } private function getBool(): bool { return (bool) 5; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Ternary::class]; } /* * @param Ternary $node / public function refactor(Node $node) : ?Node { if (!$node->if instanceof Expr) { return null; } if (!$this->valueResolver->isFalse($node->else)) { return null; } if ($this->valueResolver->isTrue($node->if)) { return null; } $ifType = $this->getType($node->if); if (!$ifType->isBoolean()->yes()) { return null; } return new BooleanAnd($node->cond, $node->if); } } PK��6(\EuG��&��Rector/Cast/RecastingRemovalRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Cast; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Cast; use PhpParser\Node\Expr\Cast\Array_; use PhpParser\Node\Expr\Cast\Bool_; use PhpParser\Node\Expr\Cast\Double; use PhpParser\Node\Expr\Cast\Int_; use PhpParser\Node\Expr\Cast\Object_; use PhpParser\Node\Expr\Cast\String_; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\StaticCall; use PHPStan\Reflection\Php\PhpPropertyReflection; use PHPStan\Type\ArrayType; use PHPStan\Type\BooleanType; use PHPStan\Type\FloatType; use PHPStan\Type\IntegerType; use PHPStan\Type\MixedType; use PHPStan\Type\ObjectType; use PHPStan\Type\StringType; use PHPStan\Type\Type; use Rector\NodeAnalyzer\ExprAnalyzer; use Rector\NodeAnalyzer\PropertyFetchAnalyzer; use Rector\Rector\AbstractRector; use Rector\Reflection\ReflectionResolver; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Cast\RecastingRemovalRector\RecastingRemovalRectorTest / final class RecastingRemovalRector extends AbstractRector { /* * @readonly * @var \Rector\NodeAnalyzer\PropertyFetchAnalyzer / private $propertyFetchAnalyzer; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\NodeAnalyzer\ExprAnalyzer / private $exprAnalyzer; /* * @var array<class-string<Node>, class-string<Type>> / private const CAST_CLASS_TO_NODE_TYPE = [String_::class => StringType::class, Bool_::class => BooleanType::class, Array_::class => ArrayType::class, Int_::class => IntegerType::class, Object_::class => ObjectType::class, Double::class => FloatType::class]; public function __construct(PropertyFetchAnalyzer $propertyFetchAnalyzer, ReflectionResolver $reflectionResolver, ExprAnalyzer $exprAnalyzer) { $this->propertyFetchAnalyzer = $propertyFetchAnalyzer; $this->reflectionResolver = $reflectionResolver; $this->exprAnalyzer = $exprAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Removes recasting of the same type', [new CodeSample(<<<'CODE_SAMPLE' $string = ''; $string = (string) $string; $array = []; $array = (array) $array; CODE_SAMPLE , <<<'CODE_SAMPLE' $string = ''; $string = $string; $array = []; $array = $array; CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Cast::class]; } /* * @param Cast $node / public function refactor(Node $node) : ?Node { $nodeClass = \get_class($node); if (!isset(self::CAST_CLASS_TO_NODE_TYPE[$nodeClass])) { return null; } $nodeType = $this->nodeTypeResolver->getNativeType($node->expr); if ($nodeType instanceof MixedType) { return null; } $sameNodeType = self::CAST_CLASS_TO_NODE_TYPE[$nodeClass]; if (!$nodeType instanceof $sameNodeType) { return null; } if ($this->shouldSkip($node->expr)) { return null; } if ($this->shouldSkipCall($node->expr)) { return null; } return $node->expr; } private function shouldSkipCall(Expr $expr) : bool { if (!$expr instanceof MethodCall && !$expr instanceof StaticCall) { return \false; } $type = $this->nodeTypeResolver->getNativeType($expr); return $type instanceof MixedType && !$type->isExplicitMixed(); } private function shouldSkip(Expr $expr) : bool { if (!$this->propertyFetchAnalyzer->isPropertyFetch($expr)) { return $this->exprAnalyzer->isNonTypedFromParam($expr); } $phpPropertyReflection = $this->reflectionResolver->resolvePropertyReflectionFromPropertyFetch($expr); if (!$phpPropertyReflection instanceof PhpPropertyReflection) { return \true; } $nativeType = $phpPropertyReflection->getNativeType(); return $nativeType instanceof MixedType; } } PK��6(\��G��)��Rector/BooleanAnd/RemoveAndTrueRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\BooleanAnd; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use Rector\PhpParser\Node\Value\ValueResolver; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\BooleanAnd\RemoveAndTrueRector\RemoveAndTrueRectorTest / final class RemoveAndTrueRector extends AbstractRector { /* * @readonly * @var \Rector\PhpParser\Node\Value\ValueResolver / private $valueResolver; public function __construct(ValueResolver $valueResolver) { $this->valueResolver = $valueResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove and true that has no added value', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { return true && 5 === 1; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { return 5 === 1; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [BooleanAnd::class]; } /* * @param BooleanAnd $node / public function refactor(Node $node) : ?Node { if ($this->isTrueOrBooleanAndTrues($node->left)) { return $node->right; } if ($this->isTrueOrBooleanAndTrues($node->right)) { return $node->left; } return null; } private function isTrueOrBooleanAndTrues(Expr $expr) : bool { if ($this->valueResolver->isTrue($expr)) { return \true; } if (!$expr instanceof BooleanAnd) { return \false; } if (!$this->isTrueOrBooleanAndTrues($expr->left)) { return \false; } return $this->isTrueOrBooleanAndTrues($expr->right); } } PK��6(\��B��6��Rector/If_/RemoveTypedPropertyDeadInstanceOfRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Expr\BooleanNot; use PhpParser\Node\Expr\Instanceof_; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Name; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\Do_; use PhpParser\Node\Stmt\For_; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\If_; use PhpParser\Node\Stmt\Property; use PhpParser\Node\Stmt\While_; use PhpParser\NodeTraverser; use Rector\NodeManipulator\IfManipulator; use Rector\Php80\NodeAnalyzer\PromotedPropertyResolver; use Rector\Rector\AbstractRector; use Rector\TypeDeclaration\AlreadyAssignDetector\ConstructorAssignDetector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\If_\RemoveTypedPropertyDeadInstanceOfRector\RemoveTypedPropertyDeadInstanceOfRectorTest / final class RemoveTypedPropertyDeadInstanceOfRector extends AbstractRector { /* * @readonly * @var \Rector\NodeManipulator\IfManipulator / private $ifManipulator; /* * @readonly * @var \Rector\TypeDeclaration\AlreadyAssignDetector\ConstructorAssignDetector / private $constructorAssignDetector; /* * @readonly * @var \Rector\Php80\NodeAnalyzer\PromotedPropertyResolver / private $promotedPropertyResolver; public function __construct(IfManipulator $ifManipulator, ConstructorAssignDetector $constructorAssignDetector, PromotedPropertyResolver $promotedPropertyResolver) { $this->ifManipulator = $ifManipulator; $this->constructorAssignDetector = $constructorAssignDetector; $this->promotedPropertyResolver = $promotedPropertyResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove dead instanceof check on type hinted property', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { private $someObject; public function __construct(SomeObject $someObject) { $this->someObject = $someObject; } public function run() { if ($this->someObject instanceof SomeObject) { return true; } return false; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { private $someObject; public function __construct(SomeObject $someObject) { $this->someObject = $someObject; } public function run() { return true; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactor(Node $node) : ?Class_ { $hasChanged = \false; $class = $node; $this->traverseNodesWithCallable($node->getMethods(), function (Node $node) use(&$hasChanged, $class) { // avoid loop ifs if ($node instanceof While_ \|\| $node instanceof Foreach_ \|\| $node instanceof For_ \|\| $node instanceof Do_) { return NodeTraverser::STOP_TRAVERSAL; } if (!$node instanceof If_) { return null; } if (!$this->ifManipulator->isIfWithoutElseAndElseIfs($node)) { return null; } if ($node->cond instanceof BooleanNot && $node->cond->expr instanceof Instanceof_) { $result = $this->refactorStmtAndInstanceof($class, $node, $node->cond->expr); if ($result !== null) { $hasChanged = \true; return $result; } } if ($node->cond instanceof Instanceof_) { $result = $this->refactorStmtAndInstanceof($class, $node, $node->cond); if ($result !== null) { $hasChanged = \true; return $result; } } return null; }); if ($hasChanged) { return $node; } return null; } /* * @return null\|Stmt[]\|int / private function refactorStmtAndInstanceof(Class_ $class, If_ $if, Instanceof_ $instanceof) { // check local property only if (!$instanceof->expr instanceof PropertyFetch \|\| !$this->isName($instanceof->expr->var, 'this')) { return null; } if (!$instanceof->class instanceof Name) { return null; } $classType = $this->nodeTypeResolver->getType($instanceof->class); $exprType = $this->nodeTypeResolver->getType($instanceof->expr); $isSameStaticTypeOrSubtype = $classType->equals($exprType) \|\| $classType->isSuperTypeOf($exprType)->yes(); if (!$isSameStaticTypeOrSubtype) { return null; } if (!$this->isInPropertyPromotedParams($class, $instanceof->expr) && $this->isSkippedPropertyFetch($class, $instanceof->expr)) { return null; } if ($if->cond !== $instanceof) { return NodeTraverser::REMOVE_NODE; } if ($if->stmts === []) { return NodeTraverser::REMOVE_NODE; } return $if->stmts; } /* * @param \PhpParser\Node\Expr\PropertyFetch\|\PhpParser\Node\Expr\StaticPropertyFetch $propertyFetch / private function isSkippedPropertyFetch(Class_ $class, $propertyFetch) : bool { $propertyName = $this->getName($propertyFetch->name); if ($propertyName === null) { return \true; } if ($this->constructorAssignDetector->isPropertyAssigned($class, $propertyName)) { return \false; } $property = $class->getProperty($propertyName); if (!$property instanceof Property) { return \true; } return $property->type === null; } /* * @param \PhpParser\Node\Expr\PropertyFetch\|\PhpParser\Node\Expr\StaticPropertyFetch $propertyFetch / private function isInPropertyPromotedParams(Class_ $class, $propertyFetch) : bool { /* @var string $propertyName / $propertyName = $this->nodeNameResolver->getName($propertyFetch); $params = $this->promotedPropertyResolver->resolveFromClass($class); foreach ($params as $param) { if ($this->nodeNameResolver->isName($param, $propertyName)) { return \true; } } return \false; } } PK��6(\:�FT-��-��;��Rector/If_/RemoveUnusedNonEmptyArrayBeforeForeachRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\ArrayDimFetch; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use PhpParser\Node\Expr\Empty_; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Foreach_; use PhpParser\Node\Stmt\If_; use PHPStan\Analyser\Scope; use Rector\Contract\PhpParser\Node\StmtsAwareInterface; use Rector\DeadCode\NodeManipulator\CountManipulator; use Rector\DeadCode\UselessIfCondBeforeForeachDetector; use Rector\NodeAnalyzer\PropertyFetchAnalyzer; use Rector\NodeManipulator\IfManipulator; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\Php\ReservedKeywordAnalyzer; use Rector\Rector\AbstractScopeAwareRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\If_\RemoveUnusedNonEmptyArrayBeforeForeachRector\RemoveUnusedNonEmptyArrayBeforeForeachRectorTest / final class RemoveUnusedNonEmptyArrayBeforeForeachRector extends AbstractScopeAwareRector { /* * @readonly * @var \Rector\DeadCode\NodeManipulator\CountManipulator / private $countManipulator; /* * @readonly * @var \Rector\NodeManipulator\IfManipulator / private $ifManipulator; /* * @readonly * @var \Rector\DeadCode\UselessIfCondBeforeForeachDetector / private $uselessIfCondBeforeForeachDetector; /* * @readonly * @var \Rector\Php\ReservedKeywordAnalyzer / private $reservedKeywordAnalyzer; /* * @readonly * @var \Rector\NodeAnalyzer\PropertyFetchAnalyzer / private $propertyFetchAnalyzer; public function __construct(CountManipulator $countManipulator, IfManipulator $ifManipulator, UselessIfCondBeforeForeachDetector $uselessIfCondBeforeForeachDetector, ReservedKeywordAnalyzer $reservedKeywordAnalyzer, PropertyFetchAnalyzer $propertyFetchAnalyzer) { $this->countManipulator = $countManipulator; $this->ifManipulator = $ifManipulator; $this->uselessIfCondBeforeForeachDetector = $uselessIfCondBeforeForeachDetector; $this->reservedKeywordAnalyzer = $reservedKeywordAnalyzer; $this->propertyFetchAnalyzer = $propertyFetchAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused if check to non-empty array before foreach of the array', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { $values = []; if ($values !== []) { foreach ($values as $value) { echo $value; } } } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { $values = []; foreach ($values as $value) { echo $value; } } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class, StmtsAwareInterface::class]; } /* * @param If_\|StmtsAwareInterface $node * @return Stmt[]\|Foreach_\|StmtsAwareInterface\|null / public function refactorWithScope(Node $node, Scope $scope) { if ($node instanceof If_) { return $this->refactorIf($node, $scope); } return $this->refactorStmtsAware($node); } private function isUselessBeforeForeachCheck(If_ $if, Scope $scope) : bool { if (!$this->ifManipulator->isIfWithOnly($if, Foreach_::class)) { return \false; } /* @var Foreach_ $foreach / $foreach = $if->stmts[0]; $foreachExpr = $foreach->expr; if ($this->shouldSkipForeachExpr($foreachExpr, $scope)) { return \false; } $ifCond = $if->cond; if ($ifCond instanceof BooleanAnd) { return $this->isUselessBooleanAnd($ifCond, $foreachExpr); } if (($ifCond instanceof Variable \|\| $this->propertyFetchAnalyzer->isPropertyFetch($ifCond)) && $this->nodeComparator->areNodesEqual($ifCond, $foreachExpr)) { $ifType = $scope->getNativeType($ifCond); return $ifType->isArray()->yes(); } if ($this->uselessIfCondBeforeForeachDetector->isMatchingNotIdenticalEmptyArray($if, $foreachExpr)) { return \true; } if ($this->uselessIfCondBeforeForeachDetector->isMatchingNotEmpty($if, $foreachExpr, $scope)) { return \true; } return $this->countManipulator->isCounterHigherThanOne($if->cond, $foreachExpr); } private function isUselessBooleanAnd(BooleanAnd $booleanAnd, Expr $foreachExpr) : bool { if (!$booleanAnd->left instanceof Variable) { return \false; } if (!$this->nodeComparator->areNodesEqual($booleanAnd->left, $foreachExpr)) { return \false; } return $this->countManipulator->isCounterHigherThanOne($booleanAnd->right, $foreachExpr); } private function refactorStmtsAware(StmtsAwareInterface $stmtsAware) : ?StmtsAwareInterface { if ($stmtsAware->stmts === null) { return null; } foreach ($stmtsAware->stmts as $key => $stmt) { if (!$stmt instanceof Foreach_) { continue; } $previousStmt = $stmtsAware->stmts[$key - 1] ?? null; if (!$previousStmt instanceof If_) { continue; } // not followed by any stmts $nextStmt = $stmtsAware->stmts[$key + 1] ?? null; if ($nextStmt instanceof Stmt) { continue; } if (!$this->uselessIfCondBeforeForeachDetector->isMatchingEmptyAndForeachedExpr($previousStmt, $stmt->expr)) { continue; } /* @var Empty_ $empty / $empty = $previousStmt->cond; // scope need to be pulled from Empty_ node to ensure it get correct type $scope = $empty->getAttribute(AttributeKey::SCOPE); if (!$scope instanceof Scope) { continue; } $ifType = $scope->getNativeType($empty->expr); if (!$ifType->isArray()->yes()) { continue; } unset($stmtsAware->stmts[$key - 1]); return $stmtsAware; } return null; } private function refactorIf(If_ $if, Scope $scope) : ?Foreach_ { if (!$this->isUselessBeforeForeachCheck($if, $scope)) { return null; } /* @var Foreach_ $stmt / $stmt = $if->stmts[0]; $ifComments = $if->getAttribute(AttributeKey::COMMENTS) ?? []; $stmtComments = $stmt->getAttribute(AttributeKey::COMMENTS) ?? []; $comments = \array_merge($ifComments, $stmtComments); $stmt->setAttribute(AttributeKey::COMMENTS, $comments); return $stmt; } private function shouldSkipForeachExpr(Expr $foreachExpr, Scope $scope) : bool { if ($foreachExpr instanceof ArrayDimFetch && $foreachExpr->dim !== null) { $exprType = $this->nodeTypeResolver->getNativeType($foreachExpr->var); $dimType = $this->nodeTypeResolver->getNativeType($foreachExpr->dim); if (!$exprType->hasOffsetValueType($dimType)->yes()) { return \true; } } if ($foreachExpr instanceof Variable) { $variableName = $this->nodeNameResolver->getName($foreachExpr); if (\is_string($variableName) && $this->reservedKeywordAnalyzer->isNativeVariable($variableName)) { return \true; } $ifType = $scope->getNativeType($foreachExpr); if (!$ifType->isArray()->yes()) { return \true; } } return \false; } } PK��6(\k�l�� 2��Rector/If_/SimplifyIfElseWithSameContentRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Else_; use PhpParser\Node\Stmt\If_; use Rector\Exception\ShouldNotHappenException; use Rector\PhpParser\Printer\BetterStandardPrinter; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\If_\SimplifyIfElseWithSameContentRector\SimplifyIfElseWithSameContentRectorTest / final class SimplifyIfElseWithSameContentRector extends AbstractRector { /* * @readonly * @var \Rector\PhpParser\Printer\BetterStandardPrinter / private $betterStandardPrinter; public function __construct(BetterStandardPrinter $betterStandardPrinter) { $this->betterStandardPrinter = $betterStandardPrinter; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove if/else if they have same content', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { if (true) { return 1; } else { return 1; } } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { return 1; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class]; } /* * @param If_ $node * @return Stmt[]\|null / public function refactor(Node $node) : ?array { if (!$node->else instanceof Else_) { return null; } if (!$this->isIfWithConstantReturns($node)) { return null; } return $node->stmts; } private function isIfWithConstantReturns(If_ $if) : bool { $possibleContents = []; $possibleContents[] = $this->betterStandardPrinter->print($if->stmts); foreach ($if->elseifs as $elseif) { $possibleContents[] = $this->betterStandardPrinter->print($elseif->stmts); } $else = $if->else; if (!$else instanceof Else_) { throw new ShouldNotHappenException(); } $possibleContents[] = $this->betterStandardPrinter->print($else->stmts); $uniqueContents = \array_unique($possibleContents); // only one content for all return \count($uniqueContents) === 1; } } PK��6(\!�P��7��Rector/If_/UnwrapFutureCompatibleIfPhpVersionRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Else_; use PhpParser\Node\Stmt\If_; use PhpParser\NodeTraverser; use Rector\DeadCode\ConditionEvaluator; use Rector\DeadCode\ConditionResolver; use Rector\DeadCode\Contract\ConditionInterface; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\If_\UnwrapFutureCompatibleIfPhpVersionRector\UnwrapFutureCompatibleIfPhpVersionRectorTest / final class UnwrapFutureCompatibleIfPhpVersionRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\ConditionEvaluator / private $conditionEvaluator; /* * @readonly * @var \Rector\DeadCode\ConditionResolver / private $conditionResolver; public function __construct(ConditionEvaluator $conditionEvaluator, ConditionResolver $conditionResolver) { $this->conditionEvaluator = $conditionEvaluator; $this->conditionResolver = $conditionResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove php version checks if they are passed', [new CodeSample(<<<'CODE_SAMPLE' // current PHP: 7.2 if (version_compare(PHP_VERSION, '7.2', '<')) { return 'is PHP 7.1-'; } else { return 'is PHP 7.2+'; } CODE_SAMPLE , <<<'CODE_SAMPLE' // current PHP: 7.2 return 'is PHP 7.2+'; CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class]; } /* * @param If_ $node * @return Stmt[]\|null\|int / public function refactor(Node $node) { if ($node->elseifs !== []) { return null; } $condition = $this->conditionResolver->resolveFromExpr($node->cond); if (!$condition instanceof ConditionInterface) { return null; } $result = $this->conditionEvaluator->evaluate($condition); if ($result === null) { return null; } // if is skipped if ($result === \true) { return $this->refactorIsMatch($node); } if ($result > 0) { return $this->refactorIsMatch($node); } return $this->refactorIsNotMatch($node); } /* * @return Stmt[]\|null / private function refactorIsMatch(If_ $if) : ?array { if ($if->elseifs !== []) { return null; } return $if->stmts; } /* * @return Stmt[]\|int / private function refactorIsNotMatch(If_ $if) { // no else → just remove the node if (!$if->else instanceof Else_) { return NodeTraverser::REMOVE_NODE; } // else is always used return $if->else->stmts; } } PK��6(\�TVҨ��)��Rector/If_/RemoveDeadInstanceOfRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use PhpParser\Node\Expr\BooleanNot; use PhpParser\Node\Expr\CallLike; use PhpParser\Node\Expr\Instanceof_; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Name; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\If_; use PhpParser\NodeTraverser; use PHPStan\Reflection\ClassReflection; use PHPStan\Type\MixedType; use PHPStan\Type\ObjectType; use Rector\NodeManipulator\IfManipulator; use Rector\Rector\AbstractRector; use Rector\Reflection\ReflectionResolver; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\If_\RemoveDeadInstanceOfRector\RemoveDeadInstanceOfRectorTest / final class RemoveDeadInstanceOfRector extends AbstractRector { /* * @readonly * @var \Rector\NodeManipulator\IfManipulator / private $ifManipulator; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; public function __construct(IfManipulator $ifManipulator, ReflectionResolver $reflectionResolver) { $this->ifManipulator = $ifManipulator; $this->reflectionResolver = $reflectionResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove dead instanceof check on type hinted variable', [new CodeSample(<<<'CODE_SAMPLE' function run(stdClass $stdClass) { if (! $stdClass instanceof stdClass) { return false; } return true; } CODE_SAMPLE , <<<'CODE_SAMPLE' function run(stdClass $stdClass) { return true; } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class]; } /* * @param If_ $node * @return Stmt[]\|null\|int\|If_ / public function refactor(Node $node) { if (!$this->ifManipulator->isIfWithoutElseAndElseIfs($node)) { return null; } if ($node->cond instanceof BooleanNot && $node->cond->expr instanceof Instanceof_) { return $this->refactorStmtAndInstanceof($node, $node->cond->expr); } if ($node->cond instanceof BooleanAnd) { return $this->refactorIfWithBooleanAnd($node); } if ($node->cond instanceof Instanceof_) { return $this->refactorStmtAndInstanceof($node, $node->cond); } return null; } /* * @return null\|Stmt[]\|int / private function refactorStmtAndInstanceof(If_ $if, Instanceof_ $instanceof) { if ($this->isInstanceofTheSameType($instanceof) !== \true) { return null; } if ($this->shouldSkipFromNotTypedParam($instanceof)) { return null; } if ($instanceof->expr instanceof Assign) { $assignExpression = new Expression($instanceof->expr); return \array_merge([$assignExpression], $if->stmts); } if ($if->cond !== $instanceof) { return NodeTraverser::REMOVE_NODE; } if ($if->stmts === []) { return NodeTraverser::REMOVE_NODE; } // unwrap stmts return $if->stmts; } private function shouldSkipFromNotTypedParam(Instanceof_ $instanceof) : bool { $nativeParamType = $this->nodeTypeResolver->getNativeType($instanceof->expr); return $nativeParamType instanceof MixedType; } private function isPropertyFetch(Expr $expr) : bool { if ($expr instanceof PropertyFetch) { return \true; } return $expr instanceof StaticPropertyFetch; } private function isInstanceofTheSameType(Instanceof_ $instanceof) : ?bool { if (!$instanceof->class instanceof Name) { return null; } // handled in another rule if ($this->isPropertyFetch($instanceof->expr) \|\| $instanceof->expr instanceof CallLike) { return null; } $classReflection = $this->reflectionResolver->resolveClassReflection($instanceof); if ($classReflection instanceof ClassReflection && $classReflection->isTrait()) { return null; } $exprType = $this->nodeTypeResolver->getNativeType($instanceof->expr); if (!$exprType instanceof ObjectType) { return null; } $className = $instanceof->class->toString(); return $exprType->isInstanceOf($className)->yes(); } private function refactorIfWithBooleanAnd(If_ $if) : ?\PhpParser\Node\Stmt\If_ { if (!$if->cond instanceof BooleanAnd) { return null; } $booleanAnd = $if->cond; if (!$booleanAnd->left instanceof Instanceof_) { return null; } $instanceof = $booleanAnd->left; if ($this->isInstanceofTheSameType($instanceof) !== \true) { return null; } $if->cond = $booleanAnd->right; return $if; } } PK��6(\��1��1��0��Rector/If_/RemoveAlwaysTrueIfConditionRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\ArrayDimFetch; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\BinaryOp\BooleanAnd; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticCall; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Stmt; use PhpParser\Node\Stmt\Else_; use PhpParser\Node\Stmt\If_; use PhpParser\NodeTraverser; use PHPStan\Type\ArrayType; use PHPStan\Type\Constant\ConstantBooleanType; use PHPStan\Type\IntersectionType; use Rector\DeadCode\NodeAnalyzer\SafeLeftTypeBooleanAndOrAnalyzer; use Rector\NodeAnalyzer\ExprAnalyzer; use Rector\PhpParser\Node\BetterNodeFinder; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\If_\RemoveAlwaysTrueIfConditionRector\RemoveAlwaysTrueIfConditionRectorTest / final class RemoveAlwaysTrueIfConditionRector extends AbstractRector { /* * @readonly * @var \Rector\NodeAnalyzer\ExprAnalyzer / private $exprAnalyzer; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\SafeLeftTypeBooleanAndOrAnalyzer / private $safeLeftTypeBooleanAndOrAnalyzer; public function __construct(ExprAnalyzer $exprAnalyzer, BetterNodeFinder $betterNodeFinder, SafeLeftTypeBooleanAndOrAnalyzer $safeLeftTypeBooleanAndOrAnalyzer) { $this->exprAnalyzer = $exprAnalyzer; $this->betterNodeFinder = $betterNodeFinder; $this->safeLeftTypeBooleanAndOrAnalyzer = $safeLeftTypeBooleanAndOrAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove if condition that is always true', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { public function go() { if (1 === 1) { return 'yes'; } return 'no'; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { public function go() { return 'yes'; return 'no'; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class]; } /* * @param If_ $node * @return int\|null\|Stmt[]\|If_ / public function refactor(Node $node) { if ($node->cond instanceof BooleanAnd) { return $this->refactorIfWithBooleanAnd($node); } if ($node->else instanceof Else_) { return null; } // just one if if ($node->elseifs !== []) { return null; } $conditionStaticType = $this->getType($node->cond); if (!$conditionStaticType instanceof ConstantBooleanType) { return null; } if (!$conditionStaticType->getValue()) { return null; } if ($this->shouldSkipExpr($node->cond)) { return null; } if ($this->shouldSkipFromVariable($node->cond)) { return null; } $hasAssign = (bool) $this->betterNodeFinder->findFirstInstanceOf($node->cond, Assign::class); if ($hasAssign) { return null; } if ($node->stmts === []) { return NodeTraverser::REMOVE_NODE; } return $node->stmts; } private function shouldSkipFromVariable(Expr $expr) : bool { /* @var Variable[] $variables / $variables = $this->betterNodeFinder->findInstancesOf($expr, [Variable::class]); foreach ($variables as $variable) { if ($this->exprAnalyzer->isNonTypedFromParam($variable)) { return \true; } $type = $this->getType($variable); if ($type instanceof IntersectionType) { foreach ($type->getTypes() as $subType) { if ($subType instanceof ArrayType) { return \true; } } } } return \false; } private function shouldSkipExpr(Expr $expr) : bool { return (bool) $this->betterNodeFinder->findInstancesOf($expr, [PropertyFetch::class, StaticPropertyFetch::class, ArrayDimFetch::class, MethodCall::class, StaticCall::class]); } private function refactorIfWithBooleanAnd(If_ $if) : ?If_ { if (!$if->cond instanceof BooleanAnd) { return null; } $booleanAnd = $if->cond; $leftType = $this->getType($booleanAnd->left); if (!$leftType instanceof ConstantBooleanType) { return null; } if (!$leftType->getValue()) { return null; } if (!$this->safeLeftTypeBooleanAndOrAnalyzer->isSafe($booleanAnd)) { return null; } $if->cond = $booleanAnd->right; return $if; } } PK��6(\S5�) �� ��Rector/If_/ReduceAlwaysFalseIfOrRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\If_; use PhpParser\Node; use PhpParser\Node\Expr\BinaryOp\BooleanOr; use PhpParser\Node\Stmt\If_; use PHPStan\Type\Constant\ConstantBooleanType; use Rector\DeadCode\NodeAnalyzer\SafeLeftTypeBooleanAndOrAnalyzer; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /** * @see \Rector\Tests\DeadCode\Rector\If_\ReduceAlwaysFalseIfOrRector\ReduceAlwaysFalseIfOrRectorTest / final class ReduceAlwaysFalseIfOrRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\SafeLeftTypeBooleanAndOrAnalyzer / private $safeLeftTypeBooleanAndOrAnalyzer; public function __construct(SafeLeftTypeBooleanAndOrAnalyzer $safeLeftTypeBooleanAndOrAnalyzer) { $this->safeLeftTypeBooleanAndOrAnalyzer = $safeLeftTypeBooleanAndOrAnalyzer; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Reduce always false in a if ( \|\| ) condition', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run(int $number) { if (! is_int($number) \|\| $number > 50) { return 'yes'; } return 'no'; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run(int $number) { if ($number > 50) { return 'yes'; } return 'no'; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [If_::class]; } /* * @param If_ $node / public function refactor(Node $node) : ?Node { if (!$node->cond instanceof BooleanOr) { return null; } $booleanOr = $node->cond; $conditionStaticType = $this->getType($booleanOr->left); if (!$conditionStaticType instanceof ConstantBooleanType) { return null; } if ($conditionStaticType->getValue()) { return null; } if (!$this->safeLeftTypeBooleanAndOrAnalyzer->isSafe($booleanOr)) { return null; } $node->cond = $booleanOr->right; return $node; } } PK��6(\��߽��0��Rector/Array_/RemoveDuplicatedArrayKeyRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Array_; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Array_; use PhpParser\Node\Expr\ArrayItem; use PhpParser\Node\Expr\PreDec; use PhpParser\Node\Expr\PreInc; use Rector\PhpParser\Printer\BetterStandardPrinter; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Array_\RemoveDuplicatedArrayKeyRector\RemoveDuplicatedArrayKeyRectorTest / final class RemoveDuplicatedArrayKeyRector extends AbstractRector { /* * @readonly * @var \Rector\PhpParser\Printer\BetterStandardPrinter / private $betterStandardPrinter; public function __construct(BetterStandardPrinter $betterStandardPrinter) { $this->betterStandardPrinter = $betterStandardPrinter; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove duplicated key in defined arrays.', [new CodeSample(<<<'CODE_SAMPLE' $item = [ 1 => 'A', 1 => 'B' ]; CODE_SAMPLE , <<<'CODE_SAMPLE' $item = [ 1 => 'B' ]; CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Array_::class]; } /* * @param Array_ $node / public function refactor(Node $node) : ?Node { $duplicatedKeysArrayItems = $this->resolveDuplicateKeysArrayItems($node); if ($duplicatedKeysArrayItems === []) { return null; } foreach ($node->items as $key => $arrayItem) { if (!$arrayItem instanceof ArrayItem) { continue; } if (!$this->isArrayItemDuplicated($duplicatedKeysArrayItems, $arrayItem)) { continue; } unset($node->items[$key]); } return $node; } /* * @return ArrayItem[] / private function resolveDuplicateKeysArrayItems(Array_ $array) : array { $arrayItemsByKeys = []; foreach ($array->items as $arrayItem) { if (!$arrayItem instanceof ArrayItem) { continue; } if (!$arrayItem->key instanceof Expr) { continue; } $keyValue = $this->betterStandardPrinter->print($arrayItem->key); $arrayItemsByKeys[$keyValue][] = $arrayItem; } return $this->filterItemsWithSameKey($arrayItemsByKeys); } /* * @param array<mixed, ArrayItem[]> $arrayItemsByKeys * @return array<ArrayItem> / private function filterItemsWithSameKey(array $arrayItemsByKeys) : array { $duplicatedArrayItems = []; foreach ($arrayItemsByKeys as $arrayItems) { if (\count($arrayItems) <= 1) { continue; } $currentArrayItem = \current($arrayItems); /* @var Expr $currentArrayItemKey / $currentArrayItemKey = $currentArrayItem->key; if ($currentArrayItemKey instanceof PreInc) { continue; } if ($currentArrayItemKey instanceof PreDec) { continue; } // keep last one \array_pop($arrayItems); $duplicatedArrayItems = \array_merge($duplicatedArrayItems, $arrayItems); } return $duplicatedArrayItems; } /* * @param ArrayItem[] $duplicatedKeysArrayItems / private function isArrayItemDuplicated(array $duplicatedKeysArrayItems, ArrayItem $arrayItem) : bool { return \in_array($arrayItem, $duplicatedKeysArrayItems, \true); } } PK��6(\�8-l��l��3��Rector/Plus/RemoveDeadZeroAndOneOperationRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Plus; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\AssignOp; use PhpParser\Node\Expr\AssignOp\Div as AssignDiv; use PhpParser\Node\Expr\AssignOp\Minus as AssignMinus; use PhpParser\Node\Expr\AssignOp\Mul as AssignMul; use PhpParser\Node\Expr\AssignOp\Plus as AssignPlus; use PhpParser\Node\Expr\BinaryOp; use PhpParser\Node\Expr\BinaryOp\Div; use PhpParser\Node\Expr\BinaryOp\Minus; use PhpParser\Node\Expr\BinaryOp\Mul; use PhpParser\Node\Expr\BinaryOp\Plus; use PhpParser\Node\Expr\ClassConstFetch; use PhpParser\Node\Expr\UnaryMinus; use Rector\PhpParser\Node\Value\ValueResolver; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Plus\RemoveDeadZeroAndOneOperationRector\RemoveDeadZeroAndOneOperationRectorTest / final class RemoveDeadZeroAndOneOperationRector extends AbstractRector { /* * @readonly * @var \Rector\PhpParser\Node\Value\ValueResolver / private $valueResolver; public function __construct(ValueResolver $valueResolver) { $this->valueResolver = $valueResolver; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove operation with 1 and 0, that have no effect on the value', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { $value = 5 1; $value = 5 + 0; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { $value = 5; $value = 5; } } CODE_SAMPLE )]); } /** * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Plus::class, Minus::class, Mul::class, Div::class, AssignPlus::class, AssignMinus::class, AssignMul::class, AssignDiv::class]; } /* * @param Plus\|Minus\|Mul\|Div\|AssignPlus\|AssignMinus\|AssignMul\|AssignDiv $node / public function refactor(Node $node) : ?Node { if ($node instanceof AssignOp) { return $this->processAssignOp($node); } // -, + return $this->processBinaryOp($node); } private function processAssignOp(AssignOp $assignOp) : ?Expr { // +=, -= if ($assignOp instanceof AssignPlus \|\| $assignOp instanceof AssignMinus) { if (!$this->valueResolver->isValue($assignOp->expr, 0)) { return null; } if ($this->nodeTypeResolver->isNumberType($assignOp->var)) { return $assignOp->var; } } // , / if ($assignOp instanceof AssignMul \|\| $assignOp instanceof AssignDiv) { if (!$this->valueResolver->isValue($assignOp->expr, 1)) { return null; } if ($this->nodeTypeResolver->isNumberType($assignOp->var)) { return $assignOp->var; } } return null; } private function processBinaryOp(Node $node) : ?Expr { if ($node instanceof Plus \|\| $node instanceof Minus) { return $this->processBinaryPlusAndMinus($node); } // , / if ($node instanceof Mul) { return $this->processBinaryMulAndDiv($node); } if ($node instanceof Div) { return $this->processBinaryMulAndDiv($node); } return null; } private function areNumberType(BinaryOp $binaryOp) : bool { if (!$this->nodeTypeResolver->isNumberType($binaryOp->left)) { return \false; } return $this->nodeTypeResolver->isNumberType($binaryOp->right); } /* * @param \PhpParser\Node\Expr\BinaryOp\Plus\|\PhpParser\Node\Expr\BinaryOp\Minus $binaryOp / private function processBinaryPlusAndMinus($binaryOp) : ?Expr { if (!$this->areNumberType($binaryOp)) { return null; } if ($this->valueResolver->isValue($binaryOp->left, 0) && $this->nodeTypeResolver->isNumberType($binaryOp->right)) { if ($binaryOp instanceof Minus) { return new UnaryMinus($binaryOp->right); } return $binaryOp->right; } if (!$this->valueResolver->isValue($binaryOp->right, 0)) { return null; } return $binaryOp->left; } /* * @param \PhpParser\Node\Expr\BinaryOp\Mul\|\PhpParser\Node\Expr\BinaryOp\Div $binaryOp / private function processBinaryMulAndDiv($binaryOp) : ?Expr { if ($binaryOp->left instanceof ClassConstFetch \|\| $binaryOp->right instanceof ClassConstFetch) { return null; } if (!$this->areNumberType($binaryOp)) { return null; } if ($binaryOp instanceof Mul && $this->valueResolver->isValue($binaryOp->left, 1) && $this->nodeTypeResolver->isNumberType($binaryOp->right)) { return $binaryOp->right; } if (!$this->valueResolver->isValue($binaryOp->right, 1)) { return null; } return $binaryOp->left; } } PK��6(\+J�� 2��Rector/Property/RemoveUselessReadOnlyTagRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Property; use PhpParser\Node; use PhpParser\Node\Param; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\Property; use PHPStan\PhpDocParser\Ast\PhpDoc\GenericTagValueNode; use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\Comments\NodeDocBlock\DocBlockUpdater; use Rector\Privatization\NodeManipulator\VisibilityManipulator; use Rector\Rector\AbstractRector; use Rector\ValueObject\PhpVersionFeature; use Rector\VersionBonding\Contract\MinPhpVersionInterface; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Property\RemoveUselessReadOnlyTagRector\RemoveUselessReadOnlyTagRectorTest / final class RemoveUselessReadOnlyTagRector extends AbstractRector implements MinPhpVersionInterface { /* * @readonly * @var \Rector\Privatization\NodeManipulator\VisibilityManipulator / private $visibilityManipulator; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; /* * @readonly * @var \Rector\Comments\NodeDocBlock\DocBlockUpdater / private $docBlockUpdater; public function __construct(VisibilityManipulator $visibilityManipulator, PhpDocInfoFactory $phpDocInfoFactory, DocBlockUpdater $docBlockUpdater) { $this->visibilityManipulator = $visibilityManipulator; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->docBlockUpdater = $docBlockUpdater; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove useless @readonly annotation on native readonly type', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { /* * @readonly / private readonly string $name; public function __construct(string $name) { $this->name = $name; } } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { private readonly string $name; public function __construct(string $name) { $this->name = $name; } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class, Property::class, Param::class]; } /* * @param Class_\|Property\|Param $node / public function refactor(Node $node) : ?Node { // for param, only on property promotion if ($node instanceof Param && $node->flags === 0) { return null; } if (!$this->visibilityManipulator->isReadonly($node)) { return null; } $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $readonlyDoc = $phpDocInfo->getByName('readonly'); if (!$readonlyDoc instanceof PhpDocTagNode) { return null; } if (!$readonlyDoc->value instanceof GenericTagValueNode) { return null; } if ($readonlyDoc->value->value !== '') { return null; } $phpDocInfo->removeByName('readonly'); $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node); return $node; } public function provideMinPhpVersion() : int { return PhpVersionFeature::READONLY_PROPERTY; } } PK��6(\1k'��-��Rector/Property/RemoveUselessVarTagRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Property; use PhpParser\Node; use PhpParser\Node\Stmt\Property; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\DeadCode\PhpDoc\TagRemover\VarTagRemover; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Property\RemoveUselessVarTagRector\RemoveUselessVarTagRectorTest / final class RemoveUselessVarTagRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\PhpDoc\TagRemover\VarTagRemover / private $varTagRemover; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(VarTagRemover $varTagRemover, PhpDocInfoFactory $phpDocInfoFactory) { $this->varTagRemover = $varTagRemover; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused @var annotation for properties', [new CodeSample(<<<'CODE_SAMPLE' final class SomeClass { /* * @var string / public string $name = 'name'; } CODE_SAMPLE , <<<'CODE_SAMPLE' final class SomeClass { public string $name = 'name'; } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Property::class]; } /* * @param Property $node / public function refactor(Node $node) : ?Node { $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node); $hasChanged = $this->varTagRemover->removeVarTagIfUseless($phpDocInfo, $node); if (!$hasChanged) { return null; } return $node; } } PK��6(\�;_��_��5��Rector/Property/RemoveUnusedPrivatePropertyRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Property; use PhpParser\Node; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Stmt\Class_; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Property; use PhpParser\Node\Stmt\Return_; use PhpParser\Node\Stmt\TraitUse; use PhpParser\NodeTraverser; use PHPStan\Analyser\Scope; use Rector\BetterPhpDocParser\PhpDoc\DoctrineAnnotationTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\DeadCode\NodeAnalyzer\PropertyWriteonlyAnalyzer; use Rector\PhpParser\NodeFinder\PropertyFetchFinder; use Rector\Rector\AbstractScopeAwareRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Property\RemoveUnusedPrivatePropertyRector\RemoveUnusedPrivatePropertyRectorTest / final class RemoveUnusedPrivatePropertyRector extends AbstractScopeAwareRector { /* * @readonly * @var \Rector\PhpParser\NodeFinder\PropertyFetchFinder / private $propertyFetchFinder; /* * @readonly * @var \Rector\DeadCode\NodeAnalyzer\PropertyWriteonlyAnalyzer / private $propertyWriteonlyAnalyzer; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(PropertyFetchFinder $propertyFetchFinder, PropertyWriteonlyAnalyzer $propertyWriteonlyAnalyzer, PhpDocInfoFactory $phpDocInfoFactory) { $this->propertyFetchFinder = $propertyFetchFinder; $this->propertyWriteonlyAnalyzer = $propertyWriteonlyAnalyzer; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove unused private properties', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { private $property; } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Class_::class]; } /* * @param Class_ $node / public function refactorWithScope(Node $node, Scope $scope) : ?Node { if ($this->shouldSkipClass($node)) { return null; } $hasChanged = \false; foreach ($node->stmts as $key => $stmt) { if (!$stmt instanceof Property) { continue; } if ($this->shouldSkipProperty($stmt)) { continue; } if (!$this->shouldRemoveProperty($node, $stmt)) { continue; } // remove property unset($node->stmts[$key]); $propertyName = $this->getName($stmt); $this->removePropertyAssigns($node, $propertyName); $hasChanged = \true; } if ($hasChanged) { return $node; } return null; } private function shouldSkipProperty(Property $property) : bool { // has some attribute logic if ($property->attrGroups !== []) { return \true; } if (\count($property->props) !== 1) { return \true; } if (!$property->isPrivate()) { return \true; } // has some possible magic if ($property->isStatic()) { return \true; } $propertyPhpDocInfo = $this->phpDocInfoFactory->createFromNode($property); if (!$propertyPhpDocInfo instanceof PhpDocInfo) { return \false; } // skip as might contain important metadata return $propertyPhpDocInfo->hasByType(DoctrineAnnotationTagValueNode::class); } private function shouldRemoveProperty(Class_ $class, Property $property) : bool { $propertyName = $this->getName($property); $propertyFetches = $this->propertyFetchFinder->findLocalPropertyFetchesByName($class, $propertyName); if ($propertyFetches === []) { return \true; } return $this->propertyWriteonlyAnalyzer->arePropertyFetchesExclusivelyBeingAssignedTo($propertyFetches); } private function shouldSkipClass(Class_ $class) : bool { foreach ($class->stmts as $stmt) { // unclear what property can be used there if ($stmt instanceof TraitUse) { return \true; } } return $this->propertyWriteonlyAnalyzer->hasClassDynamicPropertyNames($class); } private function removePropertyAssigns(Class_ $class, string $propertyName) : void { $this->traverseNodesWithCallable($class, function (Node $node) use($class, $propertyName) { if (!$node instanceof Expression && !$node instanceof Return_) { return null; } if (!$node->expr instanceof Assign) { return null; } $assign = $node->expr; if (!$this->propertyFetchFinder->isLocalPropertyFetchByName($assign->var, $class, $propertyName)) { return null; } if ($node instanceof Expression) { return NodeTraverser::REMOVE_NODE; } $node->expr = $node->expr->expr; return $node; }); } } PK��6(\�a�y� �� .��Rector/FunctionLike/RemoveDeadReturnRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\FunctionLike; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\Closure; use PhpParser\Node\Stmt\ClassMethod; use PhpParser\Node\Stmt\Else_; use PhpParser\Node\Stmt\Function_; use PhpParser\Node\Stmt\If_; use PhpParser\Node\Stmt\Return_; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\FunctionLike\RemoveDeadReturnRector\RemoveDeadReturnRectorTest / final class RemoveDeadReturnRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Remove last return in the functions, since does not do anything', [new CodeSample(<<<'CODE_SAMPLE' class SomeClass { public function run() { $shallWeDoThis = true; if ($shallWeDoThis) { return; } return; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function run() { $shallWeDoThis = true; if ($shallWeDoThis) { return; } } } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [ClassMethod::class, Function_::class, Closure::class]; } /* * @param ClassMethod\|Function_\|Closure $node / public function refactor(Node $node) : ?Node { if ($node->stmts === [] \|\| $node->stmts === null) { return null; } \end($node->stmts); $lastStmtKey = \key($node->stmts); \reset($node->stmts); $lastStmt = $node->stmts[$lastStmtKey]; if ($lastStmt instanceof If_) { if (!$this->isBareIfWithOnlyStmtEmptyReturn($lastStmt)) { return null; } $lastStmt->stmts = []; return $node; } if (!$lastStmt instanceof Return_) { return null; } if ($lastStmt->expr instanceof Expr) { return null; } unset($node->stmts[$lastStmtKey]); return $node; } private function isBareIfWithOnlyStmtEmptyReturn(If_ $if) : bool { if ($if->else instanceof Else_) { return \false; } if ($if->elseifs !== []) { return \false; } if (\count($if->stmts) !== 1) { return \false; } $onlyStmt = $if->stmts[0]; if (!$onlyStmt instanceof Return_) { return \false; } return !$onlyStmt->expr instanceof Expr; } } PK��6(\�~rQF��F��0��Rector/Expression/SimplifyMirrorAssignRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Expression; use PhpParser\Node; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Stmt\Expression; use PhpParser\NodeTraverser; use Rector\Rector\AbstractRector; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /* * @see \Rector\Tests\DeadCode\Rector\Expression\SimplifyMirrorAssignRector\SimplifyMirrorAssignRectorTest / final class SimplifyMirrorAssignRector extends AbstractRector { public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Removes unneeded $value = $value assigns', [new CodeSample(<<<'CODE_SAMPLE' function run() { $result = $result; } CODE_SAMPLE , <<<'CODE_SAMPLE' function run() { } CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Expression::class]; } /* * @param Expression $node / public function refactor(Node $node) : ?int { if (!$node->expr instanceof Assign) { return null; } $assign = $node->expr; if (!$this->nodeComparator->areNodesEqual($assign->var, $assign->expr)) { return null; } return NodeTraverser::REMOVE_NODE; } } PK��6(\AF��V��V����Rector/Expression/RemoveDeadStmtRector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\Rector\Expression; use PhpParser\Node; use PhpParser\Node\Expr\PropertyFetch; use PhpParser\Node\Expr\StaticPropertyFetch; use PhpParser\Node\Stmt\Expression; use PhpParser\Node\Stmt\Nop; use PhpParser\NodeTraverser; use PHPStan\Reflection\Php\PhpPropertyReflection; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory; use Rector\DeadCode\NodeManipulator\LivingCodeManipulator; use Rector\NodeAnalyzer\PropertyFetchAnalyzer; use Rector\NodeTypeResolver\Node\AttributeKey; use Rector\Rector\AbstractRector; use Rector\Reflection\ReflectionResolver; use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample; use Symplify\RuleDocGenerator\ValueObject\RuleDefinition; /** * @see \Rector\Tests\DeadCode\Rector\Expression\RemoveDeadStmtRector\RemoveDeadStmtRectorTest / final class RemoveDeadStmtRector extends AbstractRector { /* * @readonly * @var \Rector\DeadCode\NodeManipulator\LivingCodeManipulator / private $livingCodeManipulator; /* * @readonly * @var \Rector\NodeAnalyzer\PropertyFetchAnalyzer / private $propertyFetchAnalyzer; /* * @readonly * @var \Rector\Reflection\ReflectionResolver / private $reflectionResolver; /* * @readonly * @var \Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory / private $phpDocInfoFactory; public function __construct(LivingCodeManipulator $livingCodeManipulator, PropertyFetchAnalyzer $propertyFetchAnalyzer, ReflectionResolver $reflectionResolver, PhpDocInfoFactory $phpDocInfoFactory) { $this->livingCodeManipulator = $livingCodeManipulator; $this->propertyFetchAnalyzer = $propertyFetchAnalyzer; $this->reflectionResolver = $reflectionResolver; $this->phpDocInfoFactory = $phpDocInfoFactory; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Removes dead code statements', [new CodeSample(<<<'CODE_SAMPLE' $value = 5; $value; CODE_SAMPLE , <<<'CODE_SAMPLE' $value = 5; CODE_SAMPLE )]); } /* * @return array<class-string<Node>> / public function getNodeTypes() : array { return [Expression::class]; } /* * @param Expression $node * @return Node[]\|Node\|null\|int / public function refactor(Node $node) { if ($this->hasGetMagic($node)) { return null; } $livingCode = $this->livingCodeManipulator->keepLivingCodeFromExpr($node->expr); if ($livingCode === []) { return $this->removeNodeAndKeepComments($node); } if ($livingCode === [$node->expr]) { return null; } $newNode = clone $node; $newNode->expr = \array_shift($livingCode); $newNodes = []; foreach ($livingCode as $singleLivingCode) { $newNodes[] = new Expression($singleLivingCode); } $newNodes[] = $newNode; return $newNodes; } private function hasGetMagic(Expression $expression) : bool { if (!$this->propertyFetchAnalyzer->isPropertyFetch($expression->expr)) { return \false; } /* @var PropertyFetch\|StaticPropertyFetch $propertyFetch / $propertyFetch = $expression->expr; $phpPropertyReflection = $this->reflectionResolver->resolvePropertyReflectionFromPropertyFetch($propertyFetch); /* * property not found assume has class has __get method * that can call non-defined property, that can have some special handling, eg: throw on special case / return !$phpPropertyReflection instanceof PhpPropertyReflection; } /* * @return int\|\PhpParser\Node / private function removeNodeAndKeepComments(Expression $expression) { $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($expression); if ($expression->getComments() !== []) { $nop = new Nop(); $nop->setAttribute(AttributeKey::PHP_DOC_INFO, $phpDocInfo); return $nop; } return NodeTraverser::REMOVE_NODE; } } PK��6(\��-��-��%��SideEffect/SideEffectNodeDetector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\SideEffect; use RectorPrefix202411\Nette\Utils\Strings; use PhpParser\Node; use PhpParser\Node\Expr; use PhpParser\Node\Expr\ArrayDimFetch; use PhpParser\Node\Expr\Assign; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Expr\New_; use PhpParser\Node\Expr\NullsafeMethodCall; use PhpParser\Node\Expr\StaticCall; use PhpParser\Node\Expr\Variable; use PhpParser\Node\Name; use PhpParser\Node\Name\FullyQualified; use PHPStan\Analyser\Scope; use PHPStan\Type\ObjectType; use Rector\PhpParser\Node\BetterNodeFinder; final class SideEffectNodeDetector { /* * @readonly * @var \Rector\DeadCode\SideEffect\PureFunctionDetector / private $pureFunctionDetector; /* * @readonly * @var \Rector\PhpParser\Node\BetterNodeFinder / private $betterNodeFinder; /* * @var array<class-string<Expr>> / private const CALL_EXPR_SIDE_EFFECT_NODE_TYPES = [MethodCall::class, New_::class, NullsafeMethodCall::class, StaticCall::class]; public function __construct(\Rector\DeadCode\SideEffect\PureFunctionDetector $pureFunctionDetector, BetterNodeFinder $betterNodeFinder) { $this->pureFunctionDetector = $pureFunctionDetector; $this->betterNodeFinder = $betterNodeFinder; } public function detect(Expr $expr, Scope $scope) : bool { if ($expr instanceof Assign) { return \true; } return (bool) $this->betterNodeFinder->findFirst($expr, function (Node $subNode) use($scope) : bool { return $this->detectCallExpr($subNode, $scope); }); } public function detectCallExpr(Node $node, Scope $scope) : bool { if (!$node instanceof Expr) { return \false; } if ($node instanceof StaticCall && $this->isClassCallerThrowable($node)) { return \false; } if ($node instanceof New_ && $this->isPhpParser($node)) { return \false; } $exprClass = \get_class($node); if (\in_array($exprClass, self::CALL_EXPR_SIDE_EFFECT_NODE_TYPES, \true)) { return \true; } if ($node instanceof FuncCall) { return !$this->pureFunctionDetector->detect($node, $scope); } if ($node instanceof Variable \|\| $node instanceof ArrayDimFetch) { $variable = $this->resolveVariable($node); // variables don't have side effects return !$variable instanceof Variable; } return \false; } private function isPhpParser(New_ $new) : bool { if (!$new->class instanceof FullyQualified) { return \false; } $className = $new->class->toString(); $namespace = Strings::before($className, '\\', 1); return $namespace === 'PhpParser'; } private function isClassCallerThrowable(StaticCall $staticCall) : bool { $class = $staticCall->class; if (!$class instanceof Name) { return \false; } $throwableType = new ObjectType('Throwable'); $type = new ObjectType($class->toString()); return $throwableType->isSuperTypeOf($type)->yes(); } /* * @param \PhpParser\Node\Expr\ArrayDimFetch\|\PhpParser\Node\Expr\Variable $expr / private function resolveVariable($expr) : ?Variable { while ($expr instanceof ArrayDimFetch) { $expr = $expr->var; } if (!$expr instanceof Variable) { return null; } return $expr; } } PK��6(\����#��SideEffect/PureFunctionDetector.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\SideEffect; use PhpParser\Node\Expr\FuncCall; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; use PHPStan\Reflection\Native\NativeFunctionReflection; use PHPStan\Reflection\ReflectionProvider; use Rector\NodeNameResolver\NodeNameResolver; final class PureFunctionDetector { /** * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @readonly * @var \PHPStan\Reflection\ReflectionProvider / private $reflectionProvider; public function __construct(NodeNameResolver $nodeNameResolver, ReflectionProvider $reflectionProvider) { $this->nodeNameResolver = $nodeNameResolver; $this->reflectionProvider = $reflectionProvider; } public function detect(FuncCall $funcCall, Scope $scope) : bool { $funcCallName = $this->nodeNameResolver->getName($funcCall); if ($funcCallName === null) { return \false; } $name = new Name($funcCallName); $hasFunction = $this->reflectionProvider->hasFunction($name, $scope); if (!$hasFunction) { return \false; } $functionReflection = $this->reflectionProvider->getFunction($name, $scope); if (!$functionReflection instanceof NativeFunctionReflection) { return \false; } // yes() and maybe() may have side effect return $functionReflection->hasSideEffects()->no(); } } PK��6(\��=��=��)��NodeCollector/UnusedParameterResolver.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode\NodeCollector; use PhpParser\Node\Param; use PhpParser\Node\Stmt\ClassMethod; use Rector\NodeAnalyzer\ParamAnalyzer; final class UnusedParameterResolver { /* * @readonly * @var \Rector\NodeAnalyzer\ParamAnalyzer / private $paramAnalyzer; public function __construct(ParamAnalyzer $paramAnalyzer) { $this->paramAnalyzer = $paramAnalyzer; } /* * @return array<int, Param> / public function resolve(ClassMethod $classMethod) : array { /* @var array<int, Param> $unusedParameters / $unusedParameters = []; foreach ($classMethod->params as $i => $param) { // skip property promotion /* @var Param $param / if ($param->flags !== 0) { continue; } if ($this->paramAnalyzer->isParamUsedInClassMethod($classMethod, $param)) { continue; } $unusedParameters[$i] = $param; } return $unusedParameters; } } PK��6(\�z@s��ConditionResolver.phpnu��[��<?php declare (strict_types=1); namespace Rector\DeadCode; use PhpParser\Node\Arg; use PhpParser\Node\Expr; use PhpParser\Node\Expr\BinaryOp\Equal; use PhpParser\Node\Expr\BinaryOp\Identical; use PhpParser\Node\Expr\BinaryOp\NotEqual; use PhpParser\Node\Expr\BinaryOp\NotIdentical; use PhpParser\Node\Expr\FuncCall; use Rector\DeadCode\Contract\ConditionInterface; use Rector\DeadCode\ValueObject\BinaryToVersionCompareCondition; use Rector\DeadCode\ValueObject\VersionCompareCondition; use Rector\NodeNameResolver\NodeNameResolver; use Rector\Php\PhpVersionProvider; use Rector\PhpParser\Node\Value\ValueResolver; use Rector\Util\PhpVersionFactory; final class ConditionResolver { /* * @readonly * @var \Rector\NodeNameResolver\NodeNameResolver / private $nodeNameResolver; /* * @readonly * @var \Rector\Php\PhpVersionProvider / private $phpVersionProvider; /* * @readonly * @var \Rector\PhpParser\Node\Value\ValueResolver / private $valueResolver; public function __construct(NodeNameResolver $nodeNameResolver, PhpVersionProvider $phpVersionProvider, ValueResolver $valueResolver) { $this->nodeNameResolver = $nodeNameResolver; $this->phpVersionProvider = $phpVersionProvider; $this->valueResolver = $valueResolver; } public function resolveFromExpr(Expr $expr) : ?ConditionInterface { if ($this->isVersionCompareFuncCall($expr)) { /* @var FuncCall $expr / return $this->resolveVersionCompareConditionForFuncCall($expr); } if (!$expr instanceof Identical && !$expr instanceof Equal && !$expr instanceof NotIdentical && !$expr instanceof NotEqual) { return null; } $binaryClass = \get_class($expr); if ($this->isVersionCompareFuncCall($expr->left)) { /* @var FuncCall $funcCall / $funcCall = $expr->left; return $this->resolveFuncCall($funcCall, $expr->right, $binaryClass); } if ($this->isVersionCompareFuncCall($expr->right)) { /* @var FuncCall $funcCall / $funcCall = $expr->right; $versionCompareCondition = $this->resolveVersionCompareConditionForFuncCall($funcCall); if (!$versionCompareCondition instanceof VersionCompareCondition) { return null; } $expectedValue = $this->valueResolver->getValue($expr->left); return new BinaryToVersionCompareCondition($versionCompareCondition, $binaryClass, $expectedValue); } return null; } private function isVersionCompareFuncCall(Expr $expr) : bool { if (!$expr instanceof FuncCall) { return \false; } return $this->nodeNameResolver->isName($expr, 'version_compare'); } private function resolveVersionCompareConditionForFuncCall(FuncCall $funcCall) : ?VersionCompareCondition { $firstVersion = $this->resolveArgumentValue($funcCall, 0); if ($firstVersion === null) { return null; } $secondVersion = $this->resolveArgumentValue($funcCall, 1); if ($secondVersion === null) { return null; } // includes compare sign as 3rd argument $versionCompareSign = null; if (isset($funcCall->args[2]) && $funcCall->args[2] instanceof Arg) { $versionCompareSign = $this->valueResolver->getValue($funcCall->args[2]->value); } return new VersionCompareCondition($firstVersion, $secondVersion, $versionCompareSign); } private function resolveFuncCall(FuncCall $funcCall, Expr $expr, string $binaryClass) : ?BinaryToVersionCompareCondition { $versionCompareCondition = $this->resolveVersionCompareConditionForFuncCall($funcCall); if (!$versionCompareCondition instanceof VersionCompareCondition) { return null; } $expectedValue = $this->valueResolver->getValue($expr); return new BinaryToVersionCompareCondition($versionCompareCondition, $binaryClass, $expectedValue); } private function resolveArgumentValue(FuncCall $funcCall, int $argumentPosition) : ?int { if (!isset($funcCall->args[$argumentPosition])) { return null; } if (!$funcCall->args[$argumentPosition] instanceof Arg) { return null; } $firstArgValue = $funcCall->args[$argumentPosition]->value; /* @var mixed\|null $version / $version = $this->valueResolver->getValue($firstArgValue); if (\in_array($version, ['PHP_VERSION', 'PHP_VERSION_ID'], \true)) { return $this->phpVersionProvider->provide(); } if (\is_string($version)) { return PhpVersionFactory::createIntVersion($version); } return $version; } } PK��6(\�\|��$��NodeManipulator/CountManipulator.phpnu��[��PK��6(\��4��NodeManipulator/ControllerClassMethodManipulator.phpnu��[��PK��6(\��$cb��b��+��NodeManipulator/ClassMethodParamRemover.phpnu��[��PK��6(\��d��d��)��NodeManipulator/LivingCodeManipulator.phpnu��[��PK��6(\͐�v��v��0��.��NodeManipulator/VariadicFunctionLikeDetector.phpnu��[��PK��6(\�ڕ�� &��f5��PhpDoc/DeadVarTagValueNodeAnalyzer.phpnu��[��PK��6(\��Q!��!��(��?��PhpDoc/DeadParamTagValueNodeAnalyzer.phpnu��[��PK��6(\�)��)��!S��PhpDoc/Guard/TemplateTypeRemovalGuard.phpnu��[��PK��6(\� ��+��ZV��PhpDoc/Guard/StandaloneTypeRemovalGuard.phpnu��[��PK��6(\H`�n��)��Y��PhpDoc/DeadReturnTagValueNodeAnalyzer.phpnu��[��PK��6(\Z�=PZ��Z��&��t��PhpDoc/TagRemover/ReturnTagRemover.phpnu��[��PK��6(\�;�!� �� %��z��PhpDoc/TagRemover/ParamTagRemover.phpnu��[��PK��6(\�{��#��PhpDoc/TagRemover/VarTagRemover.phpnu��[��PK��6(\��)�g��g��ї��Contract/ConditionInterface.phpnu��[��PK��6(\�ϴ��'��ValueObject/VersionCompareCondition.phpnu��[��PK��6(\O5�l��/��ValueObject/BinaryToVersionCompareCondition.phpnu��[��PK��6(\)��-��-��1��ˡ��NodeAnalyzer/SafeLeftTypeBooleanAndOrAnalyzer.phpnu��[��PK��6(\�@��'��Y��NodeAnalyzer/ExprUsedInNodeAnalyzer.phpnu��[��PK��6(\�V��)��B��NodeAnalyzer/UsedVariableNameAnalyzer.phpnu��[��PK��6(\��ݠ����NodeAnalyzer/PropertyWriteonlyAnalyzer.phpnu��[��PK��6(\X��&��&����u��NodeAnalyzer/IsClassMethodUsedAnalyzer.phpnu��[��PK��6(\�<;��'��x��NodeAnalyzer/CallCollectionAnalyzer.phpnu��[��PK��6(\p��ConditionEvaluator.phpnu��[��PK��6(\i=E��E��&��UselessIfCondBeforeForeachDetector.phpnu��[��PK��6(\N ��<��<��,��TypeNodeAnalyzer/GenericTypeNodeAnalyzer.phpnu��[��PK��6(\c38{��{��/��5�TypeNodeAnalyzer/MixedArrayTypeNodeAnalyzer.phpnu��[��PK��6(\s-�C��5��Rector/Switch_/RemoveDuplicatedCaseInSwitchRector.phpnu��[��PK��6(\��T��9���Rector/StaticCall/RemoveParentCallWithoutParentRector.phpnu��[��PK��6(\�ң��7��=�Rector/Return_/RemoveDeadConditionAboveReturnRector.phpnu��[��PK��6(\M��4��J�Rector/Node/RemoveNonExistingVarAnnotationRector.phpnu��[��PK��6(\�n;T��T��3��i�Rector/ConstFetch/RemovePhpVersionIdCheckRector.phpnu��[��PK��6(\�"s>��>��<��Ԅ�Rector/ClassConst/RemoveUnusedPrivateClassConstantRector.phpnu��[��PK��6(\.��dc��c��$��~��Rector/For_/RemoveDeadLoopRector.phpnu��[��PK��6(\��E��(��5��Rector/For_/RemoveDeadContinueRector.phpnu��[��PK��6(\�S�A��,��Rector/For_/RemoveDeadIfForeachForRector.phpnu��[��PK��6(\�u�� 0��Rector/Stmt/RemoveUnreachableStatementRector.phpnu��[��PK��6(\��/��0��Rector/Foreach_/RemoveUnusedForeachKeyRector.phpnu��[��PK��6(\��)��=��Rector/ClassLike/RemoveTypedPropertyNonMockDocblockRector.phpnu��[��PK��6(\{�a$��$��+��Rector/ClassLike/RemoveAnnotationRector.phpnu��[��PK��6(\�[��2��Rector/Assign/RemoveUnusedVariableAssignRector.phpnu��[��PK��6(\/��4[��[����Rector/Assign/RemoveDoubleAssignRector.phpnu��[��PK��6(\5 Ɵv��v��,��=�Rector/Concat/RemoveConcatAutocastRector.phpnu��[��PK��6(\�E��B��#�Rector/PropertyProperty/RemoveNullPropertyInitializationRector.phpnu��[��PK��6(\f׵��3��"+�Rector/ClassMethod/RemoveEmptyClassMethodRector.phpnu��[��PK��6(\m�=��>��D�Rector/ClassMethod/RemoveUnusedPublicMethodParameterRector.phpnu��[��PK��6(\z�� 3��U�Rector/ClassMethod/RemoveUselessReturnTagRector.phpnu��[��PK��6(\13]��6��^�Rector/ClassMethod/RemoveUnusedPrivateMethodRector.phpnu��[��PK��6(\��(��9��[s�Rector/ClassMethod/RemoveUnusedConstructorParamRector.phpnu��[��PK��6(\X�4��?��Rector/ClassMethod/RemoveUselessReturnExprInConstructRector.phpnu��[��PK��6(\�?4P��9��Rector/ClassMethod/RemoveUnusedPromotedPropertyRector.phpnu��[��PK��6(\�� 2��?��Rector/ClassMethod/RemoveUselessParamTagRector.phpnu��[��PK��6(\��KXE��E��?��Rector/ClassMethod/RemoveUnusedPrivateMethodParameterRector.phpnu��[��PK��6(\�M��3��Y��Rector/ClassMethod/RemoveNullTagValueNodeRector.phpnu��[��PK��6(\f�\|D� �� ,��Rector/TryCatch/RemoveDeadTryCatchRector.phpnu��[��PK��6(\Y��$[��[��<��Rector/Ternary/TernaryToBooleanOrFalseToBooleanAndRector.phpnu��[��PK��6(\EuG��&��Rector/Cast/RecastingRemovalRector.phpnu��[��PK��6(\��G��)��Rector/BooleanAnd/RemoveAndTrueRector.phpnu��[��PK��6(\��B��6��Rector/If_/RemoveTypedPropertyDeadInstanceOfRector.phpnu��[��PK��6(\:�FT-��-��;��G.�Rector/If_/RemoveUnusedNonEmptyArrayBeforeForeachRector.phpnu��[��PK��6(\k�l�� 2��M�Rector/If_/SimplifyIfElseWithSameContentRector.phpnu��[��PK��6(\!�P��7��X�Rector/If_/UnwrapFutureCompatibleIfPhpVersionRector.phpnu��[��PK��6(\�TVҨ��)��d�Rector/If_/RemoveDeadInstanceOfRector.phpnu��[��PK��6(\��1��1��0�� y�Rector/If_/RemoveAlwaysTrueIfConditionRector.phpnu��[��PK��6(\S5�) �� ��Rector/If_/ReduceAlwaysFalseIfOrRector.phpnu��[��PK��6(\��߽��0��Rector/Array_/RemoveDuplicatedArrayKeyRector.phpnu��[��PK��6(\�8-l��l��3��1��Rector/Plus/RemoveDeadZeroAndOneOperationRector.phpnu��[��PK��6(\+J�� 2��Rector/Property/RemoveUselessReadOnlyTagRector.phpnu��[��PK��6(\1k'��-��Rector/Property/RemoveUselessVarTagRector.phpnu��[��PK��6(\�;_��_��5��Rector/Property/RemoveUnusedPrivatePropertyRector.phpnu��[��PK��6(\�a�y� �� .��Rector/FunctionLike/RemoveDeadReturnRector.phpnu��[��PK��6(\�~rQF��F��0��Rector/Expression/SimplifyMirrorAssignRector.phpnu��[��PK��6(\AF��V��V����+��Rector/Expression/RemoveDeadStmtRector.phpnu��[��PK��6(\��-��-��%��SideEffect/SideEffectNodeDetector.phpnu��[��PK��6(\����#��]�SideEffect/PureFunctionDetector.phpnu��[��PK��6(\��=��=��)��NodeCollector/UnusedParameterResolver.phpnu��[��PK��6(\�z@s��5!�ConditionResolver.phpnu��[��PK��L�L�� 4��

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0.07 | proxy | phpinfo | ???????????