Incorrect behavior of DocblockReturnArrayFromDirectArrayInstanceRector

[jmfeurprier]

Bug Report

Rector adds a Docblock for methods even though they override methods with existing Docblocks.

Subject	Details
Rector version	last dev-main
Installed as	composer dependency

Minimal PHP Code Causing Issue

See https://getrector.com/demo/9dc1a1da-6e22-4297-85ba-03a40194ce65

<?php

declare(strict_types=1);

interface FooInterface
{
    /**
     * @return int[]
     */
    public function getCodes(): iterable;
}

readonly abstract class FooBase
{
    /**
     * @return string[]
     */
    abstract public function getMethods(): iterable;
}

readonly class Foo extends FooBase implements FooInterface
{
    #[Override]
    public function getCodes(): iterable
    {
        return [
            200,
            201,
        ];
    }

    #[Override]
    public function getMethods(): iterable
    {
        return [
            'GET',
            'POST',
        ];
    }

    /**
     * @return string[]
     */
    public function getProtocols(): iterable
    {
        return [
            'http',
            'https',
        ];
    }
}

Responsible rules

• DocblockReturnArrayFromDirectArrayInstanceRector

Expected Behavior

Rector should not add a Docblock to methods which override a method with existing Docblock.

[samsonasik]

The change seems fine and show more detailed key type docblock array

https://phpstan.org/r/c3a4727c-eaf8-4792-afc3-e5cc110f3559

[jmfeurprier]

It indeed shows more detailed key type.

What I think is an issue is the fact that overridden methods (from inherited parent class / implemented interface) which have the type documented in their Docblocks (getCodes(...) and getMethods(...) in my example) are flagged by the DocblockReturnArrayFromDirectArrayInstanceRector rule, while local methods (like getProtocols(...) in my example) are not.

The types are not missing from the Docblocks, they're defined in the parent methods, but are ignored by the rule.

I encountered this behavior when implementing an interface from an external library. This changes the method contract by returning a "wider" type, instead of sticking to the one defined in the interface / parent class.