Soothe SA

composer.json

@@ -53,7 +53,7 @@
         "cs": ["./vendor/bin/phpcs --standard=./phpcs.xml src tests"],
         "cs-fix": ["./vendor/bin/phpcbf src tests"],
         "clean": ["./vendor/bin/phpstan clear-result-cache", "./vendor/bin/psalm --clear-cache", "rm -rf tests/tmp/*.php"],
-        "sa": ["./vendor/bin/psalm -c psalm.xml --show-info=true", "./vendor/bin/phpstan analyse -c phpstan.neon --no-progress "],
+        "sa": ["./vendor/bin/psalm -m -c psalm.xml --show-info=true", "./vendor/bin/phpstan analyse -c phpstan.neon --no-progress "],
         "metrics": ["@test", "./vendor/bin/phpmetrics --report-html=build/metrics --exclude=Exception --log-junit=build/junit.xml --junit=build/junit.xml src"],
         "phpmd": ["./vendor/bin/phpmd src/di text ./phpmd.xml"],
         "build": ["@cs", "@sa", "@pcov", "@metrics"]

src/di/AnnotatedClass.php

@@ -4,31 +4,27 @@
 
 namespace Ray\Di;
 
-use Doctrine\Common\Annotations\Reader;
+use Ray\Aop\ReflectionClass;
 use Ray\Di\Di\PostConstruct;
-use ReflectionClass;
 use ReflectionMethod;
 
 final class AnnotatedClass
 {
-    /** @var Reader */
-    private $reader;
-
     /** @var AnnotatedClassMethods */
     private $injectionMethod;
 
-    public function __construct(Reader $reader)
+    public function __construct()
     {
-        $this->reader = $reader;
-        $this->injectionMethod = new AnnotatedClassMethods($reader);
+        $this->injectionMethod = new AnnotatedClassMethods();
     }
 
     /**
      * Return factory instance
      *
      * @phpstan-param ReflectionClass<object> $class Target class reflection
      */
-    public function getNewInstance(\Ray\Aop\ReflectionClass $class): NewInstance
+
+    public function getNewInstance(ReflectionClass $class): NewInstance
     {
         $setterMethods = new SetterMethods([]);
         $methods = $class->getMethods();

src/di/AnnotatedClassMethods.php

@@ -4,7 +4,6 @@
 
 namespace Ray\Di;
 
-use Doctrine\Common\Annotations\Reader;
 use Ray\Aop\ReflectionClass;
 use Ray\Aop\ReflectionMethod;
 use Ray\Di\Di\InjectInterface;
@@ -14,16 +13,12 @@
 
 final class AnnotatedClassMethods
 {
-    /** @var Reader */
-    private $reader;
-
     /** @var NameKeyVarString */
     private $nameKeyVarString;
 
-    public function __construct(Reader $reader)
+    public function __construct()
     {
-        $this->reader = $reader;
-        $this->nameKeyVarString = new NameKeyVarString($reader);
+        $this->nameKeyVarString = new NameKeyVarString();
     }
 
     /**
@@ -48,7 +43,7 @@ public function getConstructorName(ReflectionClass $class): Name
             return new Name($named->value);
         }
 
-        $name = ($this->nameKeyVarString)(new ReflectionMethod($class->name, $constructor->name));
+        $name = ($this->nameKeyVarString)(new ReflectionMethod($class->getName(), $constructor->getName()));
         if ($name !== null) {
             return new Name($name);
         }
@@ -72,7 +67,7 @@ public function getSetterMethod(ReflectionMethod $method): ?SetterMethod
         return $setterMethod;
     }
 
-    private function getName(\Ray\Aop\ReflectionMethod $method): Name
+    private function getName(ReflectionMethod $method): Name
     {
         if (PHP_VERSION_ID >= 80000) {
             $name = Name::withAttributes($method);

src/di/Arguments.php

@@ -5,7 +5,6 @@
 namespace Ray\Di;
 
 use Ray\Di\Exception\Unbound;
-use Ray\ServiceLocator\ServiceLocator;
 use ReflectionMethod;
 
 final class Arguments
@@ -65,6 +64,6 @@ private function bindInjectionPoint(Container $container, Argument $argument): v
             return;
         }
 
-        (new Bind($container, InjectionPointInterface::class))->toInstance(new InjectionPoint($argument->get(), ServiceLocator::getReader()));
+        (new Bind($container, InjectionPointInterface::class))->toInstance(new InjectionPoint($argument->get()));
     }
 }

src/di/Bind.php

@@ -103,10 +103,12 @@ public function to(string $class): self
     /**
      * Bind to constructor
      *
-     * @param class-string                 $class class name
+     * @param class-string<T>              $class class name
      * @param array<string, string>|string $name  "varName=bindName,..." or [$varName => $bindName, $varName => $bindName...]
      *
      * @throws ReflectionException
+     *
+     * @template T of object
      */
     public function toConstructor(string $class, $name, ?InjectionPoints $injectionPoints = null, ?string $postConstruct = null): self
     {
@@ -116,7 +118,9 @@ public function toConstructor(string $class, $name, ?InjectionPoints $injectionP
 
         $this->untarget = null;
         $postConstructRef = $postConstruct ? new ReflectionMethod($class, $postConstruct) : null;
-        $this->bound = (new DependencyFactory())->newToConstructor(new ReflectionClass($class), $name, $injectionPoints, $postConstructRef);
+        /** @var ReflectionClass<object> $reflection */
+        $reflection = new ReflectionClass($class);
+        $this->bound = (new DependencyFactory())->newToConstructor($reflection, $name, $injectionPoints, $postConstructRef);
         $this->container->add($this);
 
         return $this;

src/di/BindValidator.php

@@ -50,7 +50,8 @@ public function to(string $interface, string $class): ReflectionClass
      *
      * @phpstan-param class-string $provider
      *
-     * @return ReflectionClass<object>
+     * @psalm-return ReflectionClass
+     * @phpstan-return ReflectionClass<object>
      *
      * @throws NotFound
      */

src/di/DependencyFactory.php

@@ -5,7 +5,6 @@
 namespace Ray\Di;
 
 use Ray\Aop\ReflectionClass;
-use Ray\ServiceLocator\ServiceLocator;
 use ReflectionMethod;
 
 use function assert;
@@ -20,7 +19,7 @@ final class DependencyFactory
      */
     public function newAnnotatedDependency(ReflectionClass $class): Dependency
     {
-        $annotateClass = new AnnotatedClass(ServiceLocator::getReader());
+        $annotateClass = new AnnotatedClass();
         $newInstance = $annotateClass->getNewInstance($class);
         $postConstruct = $annotateClass->getPostConstruct($class);
 

src/di/InjectionPoint.php

@@ -4,7 +4,6 @@
 
 namespace Ray\Di;
 
-use Doctrine\Common\Annotations\Reader;
 use Ray\Aop\ReflectionClass;
 use Ray\Aop\ReflectionMethod;
 use Ray\Di\Di\Qualifier;
@@ -30,14 +29,13 @@ final class InjectionPoint implements InjectionPointInterface, Serializable
     /** @var string */
     private $pName;
 
-    public function __construct(ReflectionParameter $parameter, Reader $reader)
+    public function __construct(ReflectionParameter $parameter)
     {
         $this->parameter = $parameter;
         $this->pFunction = (string) $parameter->getDeclaringFunction()->name;
         $class = $parameter->getDeclaringClass();
         $this->pClass = $class instanceof ReflectionClass ? $class->name : '';
         $this->pName = $parameter->name;
-        $this->reader = $reader;
     }
 
     /**
@@ -56,9 +54,10 @@ public function getMethod(): ReflectionMethod
         $this->parameter = $this->getParameter();
         $class = $this->parameter->getDeclaringClass();
         $method = $this->parameter->getDeclaringFunction()->getShortName();
-        assert(class_exists($class->name));
+        assert($class instanceof \ReflectionClass);
+        assert(class_exists($class->getName()));
 
-        return new ReflectionMethod($class->name, $method);
+        return new ReflectionMethod($class->getName(), $method);
     }
 
     /**
@@ -68,8 +67,9 @@ public function getClass(): ReflectionClass
     {
         $this->parameter = $this->getParameter();
         $class = $this->parameter->getDeclaringClass();
+        assert($class instanceof \ReflectionClass);
 
-        return new ReflectionClass($class->name);
+        return new ReflectionClass($class->getName());
     }
 
     /**
@@ -90,21 +90,21 @@ public function getQualifiers(): array
     }
 
     /**
-     * @return array{0: Reader, 1: string, 2: string, 3: string}
+     * @return array<string>
      */
     public function __serialize(): array
     {
-        return [$this->reader, $this->pClass, $this->pFunction, $this->pName];
+        return [$this->pClass, $this->pFunction, $this->pName];
     }
 
     /**
      * {@inheritDoc}
      *
-     * @param array{0: Reader, 1: string, 2: string, 3: string} $array
+     * @param array<string> $array
      */
     public function __unserialize(array $array): void
     {
-        [$this->reader, $this->pClass, $this->pFunction, $this->pName] = $array;
+        [$this->pClass, $this->pFunction, $this->pName] = $array;
     }
 
     public function serialize(): ?string
@@ -119,8 +119,8 @@ public function serialize(): ?string
      */
     public function unserialize($data): void
     {
-        /** @var array{0: Reader, 1: string, 2: string, 3: string} $array */
-        $array = unserialize($data, ['allowed_classes' => [Reader::class]]);
+        /** @var array<string> $array */
+        $array = unserialize($data);
         $this->__unserialize($array);
     }
 }

src/di/NameKeyVarString.php

@@ -4,7 +4,6 @@
 
 namespace Ray\Di;
 
-use Doctrine\Common\Annotations\Reader;
 use Ray\Aop\ReflectionClass;
 use Ray\Aop\ReflectionMethod;
 use Ray\Di\Di\Named;
@@ -16,14 +15,6 @@
 
 final class NameKeyVarString
 {
-    /** @var Reader */
-    private $reader;
-
-    public function __construct(Reader $reader)
-    {
-        $this->reader = $reader;
-    }
-
     public function __invoke(ReflectionMethod $method): ?string
     {
         $keyVal = [];

src/di/Untarget.php

@@ -8,14 +8,17 @@
 
 final class Untarget
 {
-    /** @var ReflectionClass<object> */
+    /**
+     * @phpstan-var ReflectionClass<object>
+     * @psalm-var ReflectionClass
+     */
     private $class;
 
     /** @var string */
     private $scope = Scope::PROTOTYPE;
 
     /**
-     * @phpstan-param class-string $class
+     * @param class-string $class
      */
     public function __construct(string $class)
     {

tests/di/AnnotatedClassTest.php

@@ -4,7 +4,6 @@
 
 namespace Ray\Di;
 
-use Doctrine\Common\Annotations\AnnotationReader;
 use LogicException;
 use PHPUnit\Framework\TestCase;
 use Ray\Aop\ReflectionClass;
@@ -17,7 +16,7 @@ class AnnotatedClassTest extends TestCase
     protected function setUp(): void
     {
         parent::setUp();
-        $this->annotatedClass = new AnnotatedClass(new AnnotationReader());
+        $this->annotatedClass = new AnnotatedClass();
     }
 
     public function testInvoke(): void

tests/di/BindTest.php

@@ -154,7 +154,7 @@ public function testProviderContext(): void
         $container = new Container();
         (new Bind($container, ProviderInterface::class))->toProvider(FakeContextualProvider::class, 'context_string');
         $instance = $container->getInstance(ProviderInterface::class, Name::ANY);
-        assert(property_exists($instance, 'context'));
+        assert(property_exists($instance, 'context')); // @phpstan-ignore-line
         $this->assertSame('context_string', $instance->context);
     }
 }

tests/di/InjectionPointTest.php

@@ -4,7 +4,6 @@
 
 namespace Ray\Di;
 
-use Doctrine\Common\Annotations\AnnotationReader;
 use PHPUnit\Framework\TestCase;
 use ReflectionParameter;
 
@@ -19,7 +18,7 @@ class InjectionPointTest extends TestCase
     protected function setUp(): void
     {
         $this->parameter = new ReflectionParameter([FakeWalkRobot::class, '__construct'], 'rightLeg');
-        $this->ip = new InjectionPoint($this->parameter, new AnnotationReader());
+        $this->ip = new InjectionPoint($this->parameter);
     }
 
     public function testGetParameter(): void

tests/di/InjectorTest.php

@@ -430,7 +430,7 @@ protected function configure()
         $instance = $injector->getInstance(FakeAop::class);
         $result = $instance->returnSame(2);
         $this->assertSame(2, $result);
-        assert(isset($instance->bindings));
+        assert(property_exists($instance, 'bindings')); // @phpstan-ignore-line
         assert(isset($instance->bindings['returnSame'][0]));
         $this->assertInstanceOf(NullInterceptor::class, $instance->bindings['returnSame'][0]);
     }