Roave\BackwardCompatibility\DetectChanges\BCBreak\FunctionBased\ParameterTypeChanged

Complexity

Total Complexity

9

Size/Duplication

Total Lines	61
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	checkSymbols()	0	4	2
A	compareParameter()	0	15	2
A	__invoke()	0	5	1
A	typeToString()	0	8	3

<?php

declare(strict_types=1);

namespace Roave\BackwardCompatibility\DetectChanges\BCBreak\FunctionBased;

use Roave\BackwardCompatibility\Change;
use Roave\BackwardCompatibility\Changes;
use Roave\BackwardCompatibility\Formatter\ReflectionFunctionAbstractName;
use Roave\BetterReflection\Reflection\ReflectionFunctionAbstract;
use Roave\BetterReflection\Reflection\ReflectionParameter;
use Roave\BetterReflection\Reflection\ReflectionType;
use function array_intersect_key;
use function array_values;
use function sprintf;

/**
 * Detects a change in a parameter type
 *
 * This is mostly useful for methods, where a change in a parameter type is not allowed in
 * inheritance/interface scenarios.
 */
final class ParameterTypeChanged implements FunctionBased
{
    /** @var ReflectionFunctionAbstractName */
    private $formatFunction;

    public function __construct()
    {
        $this->formatFunction = new ReflectionFunctionAbstractName();
    }

    public function __invoke(ReflectionFunctionAbstract $fromFunction, ReflectionFunctionAbstract $toFunction) : Changes
    {
        return Changes::fromIterator($this->checkSymbols(
            array_values($fromFunction->getParameters()),
            array_values($toFunction->getParameters())
        ));
    }

    /**
     * @param ReflectionParameter[] $from
     * @param ReflectionParameter[] $to
     *
     * @return iterable|Change[]
     */
    private function checkSymbols(array $from, array $to) : iterable
    {
        foreach (array_intersect_key($from, $to) as $index => $commonParameter) {
            yield from $this->compareParameter($commonParameter, $to[$index]);

The expression YieldFromNode returns the type Generator which is incompatible with the documented return type iterable|Roave\BackwardCompatibility\Change[].

        }
    }

    /**
     * @return iterable|Change[]
     */
    private function compareParameter(ReflectionParameter $fromParameter, ReflectionParameter $toParameter) : iterable
    {
        $fromType = $this->typeToString($fromParameter->getType());
        $toType   = $this->typeToString($toParameter->getType());

        if ($fromType !== $toType) {
            yield Change::changed(

The expression yield Roave\BackwardCompatibility\Change::changed(sprintf('The parameter $%s of %s changed from %s to %s', $fromParameter->getName(), $this->formatFunction->__invoke($fromParameter->getDeclaringFunction()), $fromType, $toType), true) returns the type Generator which is incompatible with the documented return type iterable|Roave\BackwardCompatibility\Change[].

                sprintf(
                    'The parameter $%s of %s changed from %s to %s',
                    $fromParameter->getName(),
                    $this->formatFunction->__invoke($fromParameter->getDeclaringFunction()),
                    $fromType,
                    $toType
                ),
                true
            );
        }
    }

    private function typeToString(?ReflectionType $type) : string
    {
        if (! $type) {
            return 'no type';
        }

        return ($type->allowsNull() ? '?' : '')
            . $type->__toString();
    }
}