ray-di / Ray.Di

src/di/Name.php

<?php

declare(strict_types=1);

namespace Ray\Di;

use Ray\Di\Di\Named;
use Ray\Di\Di\Qualifier;
use ReflectionAttribute;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use ReflectionParameter;

use function class_exists;
use function explode;
use function get_class;
use function is_string;
use function preg_match;
use function substr;
use function trim;

/**
 * @psalm-import-type ParameterNameMapping from Types
 */
final class Name
{
    /**
     * 'Unnamed' name
     */
    public const ANY = '';

    /** @var string */
    private $name = '';

    /**
     * Named database
     *
     * format: array<varName, NamedName>
     *
     * @var ParameterNameMapping

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

     */
    private $names;

    /**
     * @param string|ParameterNameMapping|null $name
     */
    public function __construct($name = null)
    {
        if ($name === null) {
            return;
        }

        if (is_string($name)) {
            $this->setName($name);

            return;
        }

        $this->names = $name;
    }

    /**
     * Create instance from PHP8 attributes
     *
     * psalm does not know ReflectionAttribute?? PHPStan produces no type error here.
     */
    public static function withAttributes(ReflectionMethod $method): ?self
    {
        $params = $method->getParameters();
        $names = [];
        foreach ($params as $param) {
            /** @var array<ReflectionAttribute> $attributes */
            $attributes = $param->getAttributes();
            if ($attributes) {

The expression $attributes of type ReflectionAttribute[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                $name = self::getName($attributes);
                $names[$param->name] = $name;
            }
        }

        if ($names) {
            return new self($names);

$names of type array is incompatible with the type Ray\Di\ParameterNameMapping|null|string expected by parameter $name of Ray\Di\Name::__construct().

        }

        return null;
    }

    /**
     * @param non-empty-array<ReflectionAttribute> $attributes

The doc comment non-empty-array<ReflectionAttribute> at position 0 could not be parsed: Unknown type name 'non-empty-array' at position 0 in non-empty-array<ReflectionAttribute>.

     *
     * @throws ReflectionException
     *
     * @psalm-suppress MixedAssignment
     * @psalm-suppress MixedArgument
     */
    private static function getName(array $attributes): string
    {
        $refAttribute = $attributes[0];
        $attribute = $refAttribute->newInstance();
        if ($attribute instanceof Named) {
            return $attribute->value;
        }

        $isQualifier = (bool) (new ReflectionClass($attribute))->getAttributes(Qualifier::class);
        if ($isQualifier) {
            return get_class($attribute);
        }

        return '';
    }

    public function __invoke(ReflectionParameter $parameter): string
    {
        // single variable named binding
        if ($this->name) {
            return $this->name;
        }

        $parameterName = $parameter->name;

        // multiple variable named binding
        return $this->names[$parameterName] ?? $this->names[self::ANY] ?? self::ANY;
    }

    private function setName(string $name): void
    {
        // annotation
        if (class_exists($name, false)) {
            $this->name = $name;

            return;
        }

        // single name
        // @Named(name)
        if ($name === self::ANY || preg_match('/^\w+$/', $name)) {
            $this->name = $name;

            return;
        }

        // name list
        // @Named(varName1=name1, varName2=name2)]
        $this->names = $this->parseName($name);

It seems like $this->parseName($name) of type array or array is incompatible with the declared type Ray\Di\ParameterNameMapping of property $names.

    }

    /**
     * @return ParameterNameMapping
     *
     * @psalm-pure
     */
    private function parseName(string $name): array
    {
        $names = [];
        $keyValues = explode(',', $name);
        foreach ($keyValues as $keyValue) {
            $exploded = explode('=', $keyValue);
            if (isset($exploded[1])) {
                [$key, $value] = $exploded;
                if (isset($key[0]) && $key[0] === '$') {
                    $key = substr($key, 1);
                }

                $trimedKey = trim((string) $key);

                $names[$trimedKey] = trim($value);
            }
        }

        return $names;

The expression return $names returns the type array which is incompatible with the documented return type Ray\Di\ParameterNameMapping.

    }
}