*/
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"
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;
}
}