Rector config for Shardj/zf1-future

README.md

Running

To run rector with these rules:

• Run composer require --dev rector/rector
• Add rector.php (below) in project root
• Add a rector directory
• Add CustomAddReturnTypeDeclarationRector.php (belowShardj/zf1-future) in rector dir
• Add to composer.json:

    "autoload-dev": {
        "psr-4": {
            "CustomRectorRules\\": "rector/"
        }
    },

• Run composer dump-autoload
• Run bin/rector process library/Zend/ --dry-run

CustomAddReturnTypeDeclarationRector.php

<?php

// based on AddReturnTypeDeclarationRector from rector

declare(strict_types=1);

namespace CustomRectorRules;

use PhpParser\Node;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Return_;
use PHPStan\Type\ArrayType;
use PHPStan\Type\MixedType;
use PHPStan\Type\Type;
use PHPStan\Type\VoidType;
use Rector\BetterPhpDocParser\PhpDocParser\PhpDocFromTypeDeclarationDecorator;
use Rector\Core\Contract\Rector\ConfigurableRectorInterface;
use Rector\Core\Rector\AbstractRector;
use Rector\Core\ValueObject\PhpVersionFeature;
use Rector\NodeTypeResolver\TypeComparator\TypeComparator;
use Rector\Php80\NodeAnalyzer\PhpAttributeAnalyzer;
use Rector\PhpAttribute\Printer\PhpAttributeGroupFactory;
use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
use Rector\TypeDeclaration\ValueObject\AddReturnTypeDeclaration;
use RectorPrefix20220209\Webmozart\Assert\Assert;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\ConfiguredCodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

use function array_filter;

final class CustomAddReturnTypeDeclarationRector extends AbstractRector implements ConfigurableRectorInterface
{
    /**
     * @deprecated
     * @var string
     */
    public const METHOD_RETURN_TYPES = 'method_return_types';
    /**
     * @var AddReturnTypeDeclaration[]
     */
    private $methodReturnTypes = [];
    /**
     * @readonly
     * @var TypeComparator
     */
    private $typeComparator;

    /**
     * @readonly
     * @var PhpAttributeAnalyzer
     */
    private $phpAttributeAnalyzer;
    /**
     * @readonly
     * @var PhpAttributeGroupFactory
     */
    private $phpAttributeGroupFactory;

    public function __construct(
        TypeComparator $typeComparator,
        PhpAttributeAnalyzer $phpAttributeAnalyzer,
        PhpAttributeGroupFactory $phpAttributeGroupFactory
    ) {
        $this->typeComparator           = $typeComparator;
        $this->phpAttributeAnalyzer     = $phpAttributeAnalyzer;
        $this->phpAttributeGroupFactory = $phpAttributeGroupFactory;
    }

    public function getRuleDefinition(): RuleDefinition
    {
        $arrayType = new ArrayType(new MixedType(), new MixedType());

        return new RuleDefinition('Changes defined return typehint of method and class.', [
            new ConfiguredCodeSample(
                <<<'CODE_SAMPLE'
class SomeClass
{
    public function getData()
    {
    }
}
CODE_SAMPLE
                , <<<'CODE_SAMPLE'
class SomeClass
{
    public function getData(): array
    {
    }
}
CODE_SAMPLE
                , [new AddReturnTypeDeclaration('SomeClass', 'getData', $arrayType)]
            ),
        ]);
    }

    /**
     * @return array<class-string<Node>>
     */
    public function getNodeTypes(): array
    {
        return [ClassMethod::class];
    }

    /**
     * @param ClassMethod $node
     */
    public function refactor(Node $node): ?Node
    {
        foreach ($this->methodReturnTypes as $methodReturnType) {
            if (! $this->isObjectType($node, $methodReturnType->getObjectType())) {
                continue;
            }
            if (! $this->isName($node, $methodReturnType->getMethod())) {
                continue;
            }
            $this->processClassMethodNodeWithTypehints($node, $methodReturnType->getReturnType());

            return $node;
        }

        return null;
    }

    /**
     * @param mixed[] $configuration
     */
    public function configure(array $configuration): void
    {
        $methodReturnTypes = $configuration[self::METHOD_RETURN_TYPES] ?? $configuration;
        Assert::isArray($methodReturnTypes);
        Assert::allIsAOf($methodReturnTypes, AddReturnTypeDeclaration::class);
        $this->methodReturnTypes = $methodReturnTypes;
    }

    private function processClassMethodNodeWithTypehints(ClassMethod $classMethod, Type $newType): void
    {
        // remove it
        if ($newType instanceof MixedType && ! $this->phpVersionProvider->isAtLeastPhpVersion(
                PhpVersionFeature::MIXED_TYPE
            )) {
            $classMethod->returnType = null;

            return;
        }
        // already set → no change
        if ($classMethod->returnType !== null) {
            $currentReturnType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($classMethod->returnType);
            if ($this->typeComparator->areTypesEqual($currentReturnType, $newType)) {
                return;
            }
        }

        /** @var Return_[] $returns */
        $returns      = $this->betterNodeFinder->findInstanceOf((array) $classMethod->getStmts(), Return_::class);
        $valueReturns = array_filter($returns, static fn (Return_ $return): bool => $return->expr !== null);

        $isVoid = $newType instanceof VoidType;
        $hasReturn = count($valueReturns) > 0;

        if (($isVoid && $hasReturn) || (! $isVoid && ! $hasReturn)) {
            $this->addReturnTypeWillChange($classMethod);

            return;
        }

        if ($this->phpAttributeAnalyzer->hasPhpAttribute(
            $classMethod,
            PhpDocFromTypeDeclarationDecorator::RETURN_TYPE_WILL_CHANGE_ATTRIBUTE
        )) {
            $this->removeReturnTypeWillChange($classMethod);
        }
        $returnTypeNode          = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($newType, TypeKind::RETURN());
        $classMethod->returnType = $returnTypeNode;
    }

    private function addReturnTypeWillChange(ClassMethod $node): void
    {
        if ($this->phpAttributeAnalyzer->hasPhpAttribute($node, 'ReturnTypeWillChange')) {
            return;
        }

        if ($node->returnType !== null) {
            return;
        }

        $attributeGroup = $this->phpAttributeGroupFactory->createFromClass(
            PhpDocFromTypeDeclarationDecorator::RETURN_TYPE_WILL_CHANGE_ATTRIBUTE
        );

        $node->attrGroups[] = $attributeGroup;
    }

    private function removeReturnTypeWillChange(ClassMethod $node): void
    {
        $newAttrGroups = [];
        foreach ($node->attrGroups as $attrGroup) {
            $newAttrs = [];
            foreach ($attrGroup->attrs as $attribute) {
                if ($this->nodeNameResolver->isName(
                    $attribute->name,
                    PhpDocFromTypeDeclarationDecorator::RETURN_TYPE_WILL_CHANGE_ATTRIBUTE
                )) {
                    continue;
                }
                $newAttrs[] = $attribute;
            }
            if (! empty($newAttrs)) {
                $newAttrGroups[] = new Node\AttributeGroup($newAttrs, $attrGroup->getAttributes());
            }
        }
        $node->attrGroups = $newAttrGroups;
    }
}

rector.php

<?php

declare(strict_types=1);

use CustomRectorRules\CustomAddReturnTypeDeclarationRector;
use PHPStan\Type\BooleanType;
use PHPStan\Type\IntegerType;
use PHPStan\Type\NullType;
use PHPStan\Type\ObjectType;
use PHPStan\Type\StringType;
use PHPStan\Type\UnionType;
use PHPStan\Type\VoidType;
use Rector\Core\Configuration\Option;
use Rector\Core\ValueObject\PhpVersion;
use Rector\Transform\Rector\ClassMethod\ReturnTypeWillChangeRector;
use Rector\TypeDeclaration\ValueObject\AddReturnTypeDeclaration;
use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;


return static function (ContainerConfigurator $containerConfigurator): void {
    // get parameters
    $parameters = $containerConfigurator->parameters();

    // There files cause rector to crash
    $parameters->set(Option::SKIP, [
        __DIR__ . '/library/Zend/Service/WindowsAzure',
        __DIR__ . '/library/Zend/Test',
        __DIR__ . '/library/Zend/Gdata/App/FeedSourceParent.php',
    ]);

    // run rector in library directory
    $parameters->set(Option::PATHS, [
        __DIR__ . '/library',
    ]);

    // This allows the ReturnTypeWillChangeRector rule to run
    $parameters->set(Option::PHP_VERSION_FEATURES, PhpVersion::PHP_81);

    // get services (needed for register a single rule)
    $services = $containerConfigurator->services();

    $services->set(CustomAddReturnTypeDeclarationRector::class)
        ->configure(
            [
                new AddReturnTypeDeclaration(Countable::class, 'count', new IntegerType()),

                new AddReturnTypeDeclaration(ArrayAccess::class, 'offsetExists', new BooleanType()),
                new AddReturnTypeDeclaration(ArrayAccess::class, 'offsetSet', new VoidType()),
                new AddReturnTypeDeclaration(ArrayAccess::class, 'offsetUnset', new VoidType()),

                new AddReturnTypeDeclaration(Iterator::class, 'offsetUnset', new VoidType()),
                new AddReturnTypeDeclaration(Iterator::class, 'next', new VoidType()),
                new AddReturnTypeDeclaration(Iterator::class, 'valid', new BooleanType()),
                new AddReturnTypeDeclaration(Iterator::class, 'rewind', new VoidType()),

                new AddReturnTypeDeclaration(SeekableIterator::class, 'seek', new VoidType()),

                new AddReturnTypeDeclaration(RecursiveFilterIterator::class, 'hasChildren', new BooleanType()),
                new AddReturnTypeDeclaration(RecursiveFilterIterator::class, 'seek', new UnionType([new NullType(), new ObjectType(RecursiveFilterIterator::class)])),

                new AddReturnTypeDeclaration(IteratorAggregate::class, 'getIterator', new ObjectType(Traversable::class)),

                new AddReturnTypeDeclaration(Serializable::class, 'serialize', new UnionType([new NullType(), new StringType()])),
                new AddReturnTypeDeclaration(Serializable::class, 'unserialize', new VoidType()),
            ]
        );
    $services->set(ReturnTypeWillChangeRector::class);
};