Admin

name	type	size	perms	modified	actions
[parent directory]
AccessoryLiteralStringTypeMapper.php	file	1,416 B	0644	2024-11-08 13:59:10	edit
AccessoryNonEmptyStringTypeMapper.php	file	1,422 B	0644	2024-11-08 13:59:10	edit
AccessoryNonFalsyStringTypeMapper.php	file	1,422 B	0644	2024-11-08 13:59:10	edit
AccessoryNumericStringTypeMapper.php	file	1,416 B	0644	2024-11-08 13:59:10	edit
ArrayTypeMapper.php	file	7,909 B	0644	2024-11-08 13:59:10	edit
BooleanTypeMapper.php	file	1,936 B	0644	2024-11-08 13:59:10	edit
CallableTypeMapper.php	file	1,077 B	0644	2024-11-08 13:59:10	edit
ClassStringTypeMapper.php	file	1,340 B	0644	2024-11-08 13:59:10	edit
ClosureTypeMapper.php	file	2,791 B	0644	2024-11-08 13:59:10	edit
ConditionalTypeForParameterMapper.php	file	1,506 B	0644	2024-11-08 13:59:10	edit
ConditionalTypeMapper.php	file	2,003 B	0644	2024-11-08 13:59:10	edit
FloatTypeMapper.php	file	1,303 B	0644	2024-11-08 13:59:10	edit
GenericClassStringTypeMapper.php	file	1,390 B	0644	2024-11-08 13:59:10	edit
HasMethodTypeMapper.php	file	1,282 B	0644	2024-11-08 13:59:10	edit
HasOffsetTypeMapper.php	file	879 B	0644	2024-11-08 13:59:10	edit
HasOffsetValueTypeTypeMapper.php	file	913 B	0644	2024-11-08 13:59:10	edit
HasPropertyTypeMapper.php	file	1,294 B	0644	2024-11-08 13:59:10	edit
IntegerTypeMapper.php	file	1,445 B	0644	2024-11-08 13:59:10	edit
IntersectionTypeMapper.php	file	4,992 B	0644	2024-11-08 13:59:10	edit
IterableTypeMapper.php	file	866 B	0644	2024-11-08 13:59:10	edit
MixedTypeMapper.php	file	1,507 B	0644	2024-11-08 13:59:10	edit
NeverTypeMapper.php	file	795 B	0644	2024-11-08 13:59:10	edit
NonEmptyArrayTypeMapper.php	file	903 B	0644	2024-11-08 13:59:10	edit
NullTypeMapper.php	file	1,744 B	0644	2024-11-08 13:59:10	edit
ObjectTypeMapper.php	file	2,944 B	0644	2024-11-08 13:59:10	edit
ObjectWithoutClassTypeMapper.php	file	1,881 B	0644	2024-11-08 13:59:10	edit
OversizedArrayTypeMapper.php	file	995 B	0644	2024-11-08 13:59:10	edit
ParentStaticTypeMapper.php	file	952 B	0644	2024-11-08 13:59:10	edit
ResourceTypeMapper.php	file	813 B	0644	2024-11-08 13:59:10	edit
SelfObjectTypeMapper.php	file	890 B	0644	2024-11-08 13:59:10	edit
StaticTypeMapper.php	file	1,867 B	0644	2024-11-08 13:59:10	edit
StrictMixedTypeMapper.php	file	1,541 B	0644	2024-11-08 13:59:10	edit
StringTypeMapper.php	file	1,263 B	0644	2024-11-08 13:59:10	edit
ThisTypeMapper.php	file	826 B	0644	2024-11-08 13:59:10	edit
TypeWithClassNameTypeMapper.php	file	1,356 B	0644	2024-11-08 13:59:10	edit
UnionTypeMapper.php	file	7,832 B	0644	2024-11-08 13:59:10	edit
VoidTypeMapper.php	file	1,585 B	0644	2024-11-08 13:59:10	edit

editing: ArrayTypeMapper.php

<?php

declare (strict_types=1);
namespace Rector\PHPStanStaticTypeMapper\TypeMapper;

use PhpParser\Node;
use PhpParser\Node\Identifier;
use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
use PHPStan\PhpDocParser\Ast\Type\TypeNode;
use PHPStan\Type\ArrayType;
use PHPStan\Type\ClassStringType;
use PHPStan\Type\Constant\ConstantArrayType;
use PHPStan\Type\Constant\ConstantIntegerType;
use PHPStan\Type\Generic\GenericClassStringType;
use PHPStan\Type\MixedType;
use PHPStan\Type\NeverType;
use PHPStan\Type\Type;
use PHPStan\Type\UnionType;
use Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode;
use Rector\BetterPhpDocParser\ValueObject\Type\SpacingAwareArrayTypeNode;
use Rector\PHPStanStaticTypeMapper\Contract\TypeMapperInterface;
use Rector\PHPStanStaticTypeMapper\PHPStanStaticTypeMapper;
use Rector\TypeDeclaration\NodeTypeAnalyzer\DetailedTypeAnalyzer;
use Rector\TypeDeclaration\TypeAnalyzer\GenericClassStringTypeNormalizer;
/**
 * @see \Rector\Tests\PHPStanStaticTypeMapper\TypeMapper\ArrayTypeMapperTest
 *
 * @implements TypeMapperInterface<ArrayType>
 */
final class ArrayTypeMapper implements TypeMapperInterface
{
    /**
     * @readonly
     * @var \Rector\TypeDeclaration\TypeAnalyzer\GenericClassStringTypeNormalizer
     */
    private $genericClassStringTypeNormalizer;
    /**
     * @readonly
     * @var \Rector\TypeDeclaration\NodeTypeAnalyzer\DetailedTypeAnalyzer
     */
    private $detailedTypeAnalyzer;
    /**
     * @var string
     */
    public const HAS_GENERIC_TYPE_PARENT = 'has_generic_type_parent';
    /**
     * @var \Rector\PHPStanStaticTypeMapper\PHPStanStaticTypeMapper
     */
    private $phpStanStaticTypeMapper;
    public function __construct(GenericClassStringTypeNormalizer $genericClassStringTypeNormalizer, DetailedTypeAnalyzer $detailedTypeAnalyzer)
    {
        $this->genericClassStringTypeNormalizer = $genericClassStringTypeNormalizer;
        $this->detailedTypeAnalyzer = $detailedTypeAnalyzer;
    }
    // To avoid circular dependency
    public function autowire(PHPStanStaticTypeMapper $phpStanStaticTypeMapper) : void
    {
        $this->phpStanStaticTypeMapper = $phpStanStaticTypeMapper;
    }
    public function getNodeClass() : string
    {
        return ArrayType::class;
    }
    /**
     * @param ArrayType $type
     */
    public function mapToPHPStanPhpDocTypeNode(Type $type) : TypeNode
    {
        // this cannot be handled by PHPStan $type->toPhpDocNode() as requires space removal around "|" in union type
        // then e.g. "int" instead of explicit number, and nice arrays
        $itemType = $type->getItemType();
        $isGenericArray = $this->isGenericArrayCandidate($type);
        if ($itemType instanceof UnionType && !$type instanceof ConstantArrayType && !$isGenericArray) {
            return $this->createArrayTypeNodeFromUnionType($itemType);
        }
        if ($itemType instanceof ArrayType && $this->isGenericArrayCandidate($itemType)) {
            return $this->createGenericArrayType($type, \true);
        }
        if ($isGenericArray) {
            return $this->createGenericArrayType($type, \true);
        }
        $itemTypeNode = $this->phpStanStaticTypeMapper->mapToPHPStanPhpDocTypeNode($itemType);
        return new SpacingAwareArrayTypeNode($itemTypeNode);
    }
    /**
     * @param ArrayType $type
     */
    public function mapToPhpParserNode(Type $type, string $typeKind) : ?Node
    {
        return new Identifier('array');
    }
    private function createArrayTypeNodeFromUnionType(UnionType $unionType) : SpacingAwareArrayTypeNode
    {
        $unionedArrayType = [];
        foreach ($unionType->getTypes() as $unionedType) {
            $typeNode = $this->phpStanStaticTypeMapper->mapToPHPStanPhpDocTypeNode($unionedType);
            $unionedArrayType[(string) $typeNode] = $typeNode;
        }
        if (\count($unionedArrayType) > 1) {
            return new SpacingAwareArrayTypeNode(new BracketsAwareUnionTypeNode($unionedArrayType));
        }
        /** @var TypeNode $arrayType */
        $arrayType = \array_shift($unionedArrayType);
        return new SpacingAwareArrayTypeNode($arrayType);
    }
    private function isGenericArrayCandidate(ArrayType $arrayType) : bool
    {
        if ($arrayType->getKeyType() instanceof MixedType) {
            return \false;
        }
        if ($this->isClassStringArrayType($arrayType)) {
            return \true;
        }
        // skip simple arrays, like "string[]", from converting to obvious "array<int, string>"
        if ($this->isIntegerKeyAndNonNestedArray($arrayType)) {
            return \false;
        }
        if ($arrayType->getKeyType() instanceof NeverType) {
            return \false;
        }
        // make sure the integer key type is not natural/implicit array int keys
        $keysArrayType = $arrayType->getKeysArray();
        if (!$keysArrayType instanceof ConstantArrayType) {
            return \true;
        }
        foreach ($keysArrayType->getValueTypes() as $key => $keyType) {
            if (!$keyType instanceof ConstantIntegerType) {
                return \true;
            }
            if ($key !== $keyType->getValue()) {
                return \true;
            }
        }
        return \false;
    }
    private function createGenericArrayType(ArrayType $arrayType, bool $withKey = \false) : GenericTypeNode
    {
        $itemType = $arrayType->getItemType();
        $itemTypeNode = $this->phpStanStaticTypeMapper->mapToPHPStanPhpDocTypeNode($itemType);
        $identifierTypeNode = new IdentifierTypeNode('array');
        // is class-string[] list only
        if ($this->isClassStringArrayType($arrayType)) {
            $withKey = \false;
        }
        if ($withKey) {
            $keyTypeNode = $this->phpStanStaticTypeMapper->mapToPHPStanPhpDocTypeNode($arrayType->getKeyType());
            if ($itemTypeNode instanceof BracketsAwareUnionTypeNode && $this->isPairClassTooDetailed($itemType)) {
                $genericTypes = [$keyTypeNode, $this->phpStanStaticTypeMapper->mapToPHPStanPhpDocTypeNode(new ClassStringType())];
            } else {
                $genericTypes = [$keyTypeNode, $itemTypeNode];
            }
        } else {
            $genericTypes = [$itemTypeNode];
        }
        // @see https://github.com/phpstan/phpdoc-parser/blob/98a088b17966bdf6ee25c8a4b634df313d8aa531/tests/PHPStan/Parser/PhpDocParserTest.php#L2692-L2696
        foreach ($genericTypes as $genericType) {
            /** @var \PHPStan\PhpDocParser\Ast\Node $genericType */
            $genericType->setAttribute(self::HAS_GENERIC_TYPE_PARENT, $withKey);
        }
        $identifierTypeNode->setAttribute(self::HAS_GENERIC_TYPE_PARENT, $withKey);
        return new GenericTypeNode($identifierTypeNode, $genericTypes);
    }
    private function isPairClassTooDetailed(Type $itemType) : bool
    {
        if (!$itemType instanceof UnionType) {
            return \false;
        }
        if (!$this->genericClassStringTypeNormalizer->isAllGenericClassStringType($itemType)) {
            return \false;
        }
        return $this->detailedTypeAnalyzer->isTooDetailed($itemType);
    }
    private function isIntegerKeyAndNonNestedArray(ArrayType $arrayType) : bool
    {
        if (!$arrayType->getKeyType()->isInteger()->yes()) {
            return \false;
        }
        return !$arrayType->getItemType() instanceof ArrayType;
    }
    private function isClassStringArrayType(ArrayType $arrayType) : bool
    {
        if ($arrayType->getKeyType() instanceof MixedType) {
            return $arrayType->getItemType() instanceof GenericClassStringType;
        }
        if ($arrayType->getKeyType() instanceof ConstantIntegerType) {
            return $arrayType->getItemType() instanceof GenericClassStringType;
        }
        return \false;
    }
}

cancel