SignpostMarv\DaftObject\PHPStan\PropertyReflectionExtension::__construct()

Complexity

Conditions	9
Paths	18

Size

Total Lines	97
Code Lines	58

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function __construct(
        ClassReflection $classReflection,
        Broker $broker,
        string $propertyName
    ) {
        if (
            false === is_a(
                $classReflection->getName(),
                DaftObject::class,
                true
            )
        ) {
            throw new InvalidArgumentException(
                $classReflection->getName() .
                ' is not an implementation of ' .
                DaftObject::class
            );
        }

        $className = $classReflection->getName();

        $this->public =
            in_array(
                $propertyName,
                $className::DaftObjectPublicGetters(),
                true
            ) ||
            in_array(
                $propertyName,
                $className::DaftObjectPublicSetters(),
                true
            );

        $type = new MixedType();

        $getter = 'Get' . ucfirst($propertyName);
        $setter = 'Set' . ucfirst($propertyName);

        $this->readableDeclaringClass = $classReflection;
        $this->writeableDeclaringClass = $classReflection;

        if ($classReflection->getNativeReflection()->hasMethod($getter)) {
            $this->readable = true;

            $refMethod = new ReflectionMethod($className, $getter);

            if ($refMethod->isStatic()) {
                throw new InvalidArgumentException(
                    'Implementations of ' .
                    DaftObject::class .
                    ' must not contain static getters.'
                );
            }

            if ($refMethod->hasReturnType()) {
                $type = TypehintHelper::decideTypeFromReflection(
                    $refMethod->getReturnType()
                );
            }

            $this->readableDeclaringClass = $broker->getClassFromReflection(
                $refMethod->getDeclaringClass(),
                $refMethod->getDeclaringClass()->getName()
            );
        }

        if ($classReflection->getNativeReflection()->hasMethod($setter)) {
            $this->writeable = true;

            $refMethod = new ReflectionMethod($className, $setter);

            if ($refMethod->getNumberOfRequiredParameters() < 1) {
                throw new InvalidArgumentException(
                    'Implementations of ' .
                    DaftObject::class .
                    ' must require at least one parameter on all setters!'
                );
            }

            $refParam = $refMethod->getParameters()[0];

            if ($refParam->hasType()) {

The method hasType() does not exist on ReflectionParameter.

                $type = TypehintHelper::decideTypeFromReflection(
                    $refParam->getType(),

The method getType() does not exist on ReflectionParameter.

                    null,
                    $className,
                    false
                );
            }

            $this->writeableDeclaringClass = $broker->getClassFromReflection(
                $refMethod->getDeclaringClass(),
                $refMethod->getDeclaringClass()->getName()
            );
        }

        $this->type = $type;
    }