Yiisoft\Definitions\ParameterDefinition

Complexity

Total Complexity

36

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	isVariadic()	0	3	1
A	isOptional()	0	3	1
A	getReflection()	0	3	1
A	getCallable()	0	14	2
A	resolveVariadicOrBuiltinOrIntersectionOrNonTyped()	0	26	3
A	getType()	0	4	2
C	resolveUnionType()	0	68	12
A	__construct()	0	3	1
C	resolve()	0	51	12
A	hasValue()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Definitions;

use Psr\Container\ContainerInterface;
use ReflectionIntersectionType;

The type ReflectionIntersectionType was not found. Maybe you did not declare it correctly or list all dependencies?

use ReflectionNamedType;
use ReflectionParameter;
use ReflectionUnionType;
use Throwable;
use Yiisoft\Definitions\Contract\DefinitionInterface;
use Yiisoft\Definitions\Exception\CircularReferenceException;
use Yiisoft\Definitions\Exception\NotInstantiableException;
use Yiisoft\Definitions\Exception\InvalidConfigException;

/**
 * Parameter definition resolves an object based on information from `ReflectionParameter` instance.
 */
final class ParameterDefinition implements DefinitionInterface
{
    public function __construct(
        private ReflectionParameter $parameter
    ) {
    }

    public function getReflection(): ReflectionParameter
    {
        return $this->parameter;
    }

    public function isVariadic(): bool
    {
        return $this->parameter->isVariadic();
    }

    public function isOptional(): bool
    {
        return $this->parameter->isOptional();
    }

    public function hasValue(): bool
    {
        return $this->parameter->isDefaultValueAvailable();
    }

    public function resolve(ContainerInterface $container): mixed
    {
        /** @var ReflectionIntersectionType|ReflectionNamedType|ReflectionUnionType|null $type */
        $type = $this->parameter->getType();

        if ($type instanceof ReflectionUnionType) {
            return $this->resolveUnionType($container);
        }

        if ($type === null
            || $type instanceof ReflectionIntersectionType
            || $this->isVariadic()
            || $type->isBuiltin()
        ) {
            return $this->resolveVariadicOrBuiltinOrIntersectionOrNonTyped();
        }

        $typeName = $type->getName();
        /**
         * @psalm-suppress TypeDoesNotContainType
         * @see https://github.com/vimeo/psalm/issues/6756
         */
        if ($typeName === 'self') {
            // If type name is "self", it means that called class and
            // $parameter->getDeclaringClass() returned instance of `ReflectionClass`.
            /** @psalm-suppress PossiblyNullReference */
            $typeName = $this->parameter->getDeclaringClass()->getName();
        }

        try {
            $result = $container->get($typeName);
        } catch (Throwable $t) {
            if (
                $this->parameter->isOptional()
                && (
                    $t instanceof CircularReferenceException
                    || !$container->has($typeName)
                )
            ) {
                return $this->parameter->getDefaultValue();
            }
            throw $t;
        }

        if (!$result instanceof $typeName) {
            $actualType = get_debug_type($result);
            throw new InvalidConfigException(
                "Container returned incorrect type \"$actualType\" for service \"{$type->getName()}\"."
            );
        }
        return $result;
    }

    /**
     * @throws NotInstantiableException
     */
    private function resolveVariadicOrBuiltinOrIntersectionOrNonTyped(): mixed
    {
        if ($this->parameter->isDefaultValueAvailable()) {
            return $this->parameter->getDefaultValue();
        }

        $type = $this->getType();

        if ($type === null) {
            throw new NotInstantiableException(
                sprintf(
                    'Can not determine value of the "%s" parameter without type when instantiating "%s". ' .
                    'Please specify argument explicitly.',
                    $this->parameter->getName(),
                    $this->getCallable(),
                )
            );
        }

        throw new NotInstantiableException(
            sprintf(
                'Can not determine value of the "%s" parameter of type "%s" when instantiating "%s". ' .
                'Please specify argument explicitly.',
                $this->parameter->getName(),
                $type,
                $this->getCallable(),
            )
        );
    }

    /**
     * Resolve union type string provided as a class name.
     *
     * @throws InvalidConfigException If an object of incorrect type was created.
     * @throws Throwable
     *
     * @return mixed Ready to use object or null if definition can not be resolved and is marked as optional.
     */
    private function resolveUnionType(ContainerInterface $container): mixed
    {
        /**
         * @var ReflectionUnionType $parameterType
         */
        $parameterType = $this->parameter->getType();

        /**
         * @var ReflectionIntersectionType[]|ReflectionNamedType[] $types
         */
        $types = $parameterType->getTypes();
        $class = implode('|', $types);

        foreach ($types as $type) {
            if ($type instanceof ReflectionIntersectionType || $type->isBuiltin()) {
                continue;
            }

            $typeName = $type->getName();
            /**
             * @psalm-suppress TypeDoesNotContainType
             *
             * @link https://github.com/vimeo/psalm/issues/6756
             */
            if ($typeName === 'self') {
                // If type name is "self", it means that called class and
                // $parameter->getDeclaringClass() returned instance of `ReflectionClass`.
                /** @psalm-suppress PossiblyNullReference */
                $typeName = $this->parameter->getDeclaringClass()->getName();
            }

            try {
                $result = $container->get($typeName);
                $resolved = true;
            } catch (Throwable $t) {
                $error = $t;
                $resolved = false;
            }

            if ($resolved) {
                /** @var mixed $result Exist, because $resolved is true */
                if (!$result instanceof $typeName) {
                    $actualType = get_debug_type($result);
                    throw new InvalidConfigException(
                        "Container returned incorrect type \"$actualType\" for service \"$class\"."
                    );
                }
                return $result;
            }

            /** @var Throwable $error Exist, because $resolved is false */
            if (
                !$error instanceof CircularReferenceException

The variable $error does not seem to be defined for all execution paths leading up to this point.

                && $container->has($typeName)
            ) {
                throw $error;
            }
        }

        if ($this->parameter->isOptional()) {
            return null;
        }

        if (!isset($error)) {
            return $this->resolveVariadicOrBuiltinOrIntersectionOrNonTyped();
        }

        throw $error;
    }

    private function getType(): ?string
    {
        $type = $this->parameter->getType();
        return $type === null ? null : (string) $type;
    }

    private function getCallable(): string
    {
        $callable = [];

        $class = $this->parameter->getDeclaringClass();
        if ($class !== null) {
            $callable[] = $class->getName();
        }
        $callable[] = $this->parameter
                ->getDeclaringFunction()
                ->getName() .
            '()';

        return implode('::', $callable);
    }
}