ray-di / Ray.Di

src/di/Arguments.php

<?php

declare(strict_types=1);

namespace Ray\Di;

use Ray\Di\Exception\Unbound;
use ReflectionMethod;

/**
 * @psalm-import-type ArgumentsList from Types
 * @psalm-import-type MethodArguments from Types
 */
final class Arguments implements AcceptInterface
{
    /** @var ArgumentsList */

The type Ray\Di\ArgumentsList was not found. Maybe you did not declare it correctly or list all dependencies?

    private $arguments = [];

    public function __construct(ReflectionMethod $method, Name $name)
    {
        $parameters = $method->getParameters();
        foreach ($parameters as $parameter) {
            $this->arguments[] = new Argument($parameter, $name($parameter));
        }
    }

    /**
     * Return arguments
     *
     * @return list<mixed>

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

     *
     * @throws Exception\Unbound
     */
    public function inject(Container $container): array
    {
        $parameters = [];
        foreach ($this->arguments as $parameter) {
            /** @psalm-suppress MixedAssignment */
            $parameters[] = $this->getParameter($container, $parameter);
        }

        return $parameters;
    }

    public function accept(VisitorInterface $visitor)
    {
        $visitor->visitArguments($this->arguments);

$this->arguments of type Ray\Di\ArgumentsList is incompatible with the type array expected by parameter $arguments of Ray\Di\VisitorInterface::visitArguments().

    }

    /**
     * @return mixed
     *
     * @throws Unbound
     */
    private function getParameter(Container $container, Argument $argument)
    {
        $this->bindInjectionPoint($container, $argument);
        try {
            return $container->getDependency((string) $argument);
        } catch (Unbound $e) {
            if ($argument->isDefaultAvailable()) {
                return $argument->getDefaultValue();
            }

            throw new Unbound($argument->getMeta(), 0, $e);
        }
    }

    private function bindInjectionPoint(Container $container, Argument $argument): void
    {
        $isSelf = (string) $argument === InjectionPointInterface::class . '-' . Name::ANY;
        if ($isSelf) {
            return;
        }

        (new Bind($container, InjectionPointInterface::class))->toInstance(new InjectionPoint($argument->get()));
    }
}