drop annotated with

docs/attributes.md

@@ -64,7 +64,7 @@ $di->params['Example']['foo'] = $di->lazyNew(Foo::class);
 
 ## Value Attribute
 
-If the parameter is annotated with the `#[Value]` attribute, you define a new value that should be injected. 
+If a parameter is annotated with the `#[Value]` attribute, you define that a value should be injected. 
 
 For example, look at the following class; the `$foo` constructor parameter has such an annotation:
 

src/Attribute/DefineInterface.php

@@ -10,7 +10,9 @@
 
 namespace Aura\Di\Attribute;
 
+use Aura\Di\Resolver\Resolver;
+
 interface DefineInterface
 {
-    public function define(\Reflector $reflector): mixed;
+    public function define(Resolver $resolver, \Reflector $reflector): void;
 }

src/Resolver/AnnotatedResolverFactory.php

@@ -100,7 +100,7 @@ protected function detectAnnotatedClasses(Resolver $resolver): void
             foreach ($reflectionClass->getAttributes(DefineInterface::class, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
                 /** @var DefineInterface $instance */
                 $instance = $attribute->newInstance();
-                $resolver->annotations[$attribute->getName()][] = $instance->define($reflectionClass);
+                $instance->define($resolver, $reflectionClass);
             }
 
             $methods = $reflectionClass->getMethods();
@@ -110,7 +110,7 @@ protected function detectAnnotatedClasses(Resolver $resolver): void
                     foreach ($parameter->getAttributes(DefineInterface::class) as $attribute) {
                         /** @var DefineInterface $instance */
                         $instance = $attribute->newInstance();
-                        $resolver->annotations[$attribute->getName()][] = $instance->define($parameter);
+                        $instance->define($resolver, $parameter);
                     }
                 }
             }
@@ -120,7 +120,7 @@ protected function detectAnnotatedClasses(Resolver $resolver): void
                 foreach ($property->getAttributes(DefineInterface::class) as $attribute) {
                     /** @var DefineInterface $instance */
                     $instance = $attribute->newInstance();
-                    $resolver->annotations[$attribute->getName()][] = $instance->define($property);
+                    $instance->define($resolver, $property);
                 }
             }
 
@@ -130,7 +130,7 @@ protected function detectAnnotatedClasses(Resolver $resolver): void
                 foreach ($constant->getAttributes(DefineInterface::class) as $attribute) {
                     /** @var DefineInterface $instance */
                     $instance = $attribute->newInstance();
-                    $resolver->annotations[$attribute->getName()][] = $instance->define($constant);
+                    $instance->define($resolver, $constant);
                 }
             }
         }

src/Resolver/Resolver.php

@@ -34,8 +34,6 @@
  *
  * @property array $values
  *
- * @property array $annotations
- *
  */
 class Resolver
 {
@@ -93,15 +91,6 @@ class Resolver
      */
     protected array $values = [];
 
-    /**
-     *
-     * Annotations that need to be injected inside objects annotated with AnnotatedWith.
-     *
-     * @var array
-     *
-     */
-    protected array $annotations = [];
-
     /**
      *
      * Constructor params and setter definitions, unified across class

tests/ContainerBuilderTest.php

@@ -200,7 +200,7 @@ public function testCompilationSerialization()
         $this->assertCount(1, $injectedWith->getWorkers());
 
         $annotation = $injectedWith->getWorkers()[0];
-        $this->assertSame(3, $annotation->getSomeSetting());
-        $this->assertSame('Aura\Di\Fake\FakeConstructAttributeClass', $annotation->getClassName());
+        $this->assertSame(3, $annotation['someSetting']);
+        $this->assertSame('Aura\Di\Fake\FakeConstructAttributeClass', $annotation['className']);
     }
 }

tests/Fake/FakeInjectAnnotatedWithClass.php

@@ -1,14 +1,14 @@
 <?php
 namespace Aura\Di\Fake;
 
-use Aura\Di\Attribute\AnnotatedWith;
+use Aura\Di\Attribute\Value;
 
 class FakeInjectAnnotatedWithClass
 {
     private array $workers;
 
     public function __construct(
-        #[AnnotatedWith(FakeWorkerAttribute::class)]
+        #[Value('worker')]
         array $workers,
     ) {
         $this->workers = $workers;

tests/Fake/FakeWorkerAttribute.php

@@ -2,35 +2,25 @@
 namespace Aura\Di\Fake;
 
 use Aura\Di\Attribute\DefineInterface;
+use Aura\Di\Resolver\Resolver;
 
 #[\Attribute]
 class FakeWorkerAttribute implements DefineInterface
 {
     private int $someSetting;
-    private ?string $className = null;
 
     public function __construct(int $someSetting = 1)
     {
         $this->someSetting = $someSetting;
     }
 
-    public function define(\Reflector $reflector): mixed
+    public function define(Resolver $resolver, \Reflector $reflector): void
     {
         if ($reflector instanceof \ReflectionClass) {
-            $this->className = $reflector->getName();
-            return $this;
+            $resolver->values['worker'][] = [
+                'someSetting' => $this->someSetting,
+                'className' => $reflector->getName(),
+            ];
         }
-
-        throw new \UnexpectedValueException('FakeWorkerAttribute is only applicable for methods');
-    }
-
-    public function getSomeSetting(): int
-    {
-        return $this->someSetting;
-    }
-
-    public function getClassName(): ?string
-    {
-        return $this->className;
     }
 }

tests/Resolver/AnnotatedResolverFactoryTest.php

@@ -20,6 +20,7 @@ class AnnotatedResolverFactoryTest extends TestCase
     protected function setUp(): void
     {
         parent::setUp();
+
         $annotatedResolverFactory = new AnnotatedResolverFactory(
             new ResolverFactory(),
             ['Aura\Di\Fake'],
@@ -33,11 +34,11 @@ public function testAnnotatedWith()
     {
         $this->resolver->compile();
 
-        $this->assertCount(1, $this->resolver->annotations);
+        $this->assertCount(1, $this->resolver->values['worker']);
 
-        $annotation = $this->resolver->annotations[FakeWorkerAttribute::class][0];
-        $this->assertSame(3, $annotation->getSomeSetting());
-        $this->assertSame('Aura\Di\Fake\FakeConstructAttributeClass', $annotation->getClassName());
+        $annotation = $this->resolver->values['worker'][0];
+        $this->assertSame(3, $annotation['someSetting']);
+        $this->assertSame('Aura\Di\Fake\FakeConstructAttributeClass', $annotation['className']);
 
         /** @var FakeInjectAnnotatedWithClass $injectedWith */
         $injectedWith = $this->resolver->resolve(new Blueprint(FakeInjectAnnotatedWithClass::class));
@@ -52,9 +53,9 @@ public function testAttributes()
         $this->resolver->values['fake.value'] = 'value';
         $this->resolver->compile();
 
-        $this->assertCount(1, $this->resolver->annotations);
-        $this->assertSame(3, $this->resolver->annotations[FakeWorkerAttribute::class][0]->getSomeSetting());
-        $this->assertSame('Aura\Di\Fake\FakeConstructAttributeClass', $this->resolver->annotations[FakeWorkerAttribute::class][0]->getClassName());
+        $this->assertCount(1, $this->resolver->values['worker']);
+        $this->assertSame(3, $this->resolver->values['worker'][0]['someSetting']);
+        $this->assertSame('Aura\Di\Fake\FakeConstructAttributeClass', $this->resolver->values['worker'][0]['className']);
 
         $actual = $this->resolver->resolve(new Blueprint('Aura\Di\Fake\FakeConstructAttributeClass'));
         $this->assertInstanceOf('Aura\Di\Fake\FakeInterfaceClass1', $actual->getFakeService());