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

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

???????
PK��@%\�ڕ�� 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��@%\��Q!��!��!��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��@%\�)��"��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��@%\� ��$��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��@%\H`�n��"��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��@%\Z�=PZ��Z��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��@%\�;�!� �� 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��@%\�{��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��NE%\��Y��Y��VarTagValueNodeRenamer.phpnu��[��<?php declare (strict_types=1); namespace Rector\Naming\PhpDoc; use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo; use Rector\BetterPhpDocParser\ValueObject\PhpDocAttributeKey; final class VarTagValueNodeRenamer { public function renameAssignVarTagVariableName(PhpDocInfo $phpDocInfo, string $originalName, string $expectedName) : void { $varTagValueNode = $phpDocInfo->getVarTagValueNode(); if (!$varTagValueNode instanceof VarTagValueNode) { return; } if ($varTagValueNode->variableName !== '$' . $originalName) { return; } $varTagValueNode->variableName = '$' . $expectedName; // invoke node reprint - same as in php-parser $varTagValueNode->setAttribute(PhpDocAttributeKey::ORIG_NODE, null); } } PK��@%\�ڕ�� DeadVarTagValueNodeAnalyzer.phpnu��[��PK��@%\��Q!��!��!��; ��DeadParamTagValueNodeAnalyzer.phpnu��[��PK��@%\�)��"��Guard/TemplateTypeRemovalGuard.phpnu��[��PK��@%\� ��$�� Guard/StandaloneTypeRemovalGuard.phpnu��[��PK��@%\H`�n��"��$��DeadReturnTagValueNodeAnalyzer.phpnu��[��PK��@%\Z�=PZ��Z��i?��TagRemover/ReturnTagRemover.phpnu��[��PK��@%\�;�!� �� E��TagRemover/ParamTagRemover.phpnu��[��PK��@%\�{��N��TagRemover/VarTagRemover.phpnu��[��PK��NE%\��Y��Y��3b��VarTagValueNodeRenamer.phpnu��[��PK�� [��e��

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