misc: refactor attribute definition to include class definition

src/Definition/AttributeDefinition.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Definition;
+
+/** @internal */
+final class AttributeDefinition
+{
+    public function __construct(
+        private ClassDefinition $class,
+        /** @var list<mixed> */
+        private array $arguments,
+    ) {}
+
+    public function class(): ClassDefinition
+    {
+        return $this->class;
+    }
+
+    /**
+     * @return list<mixed>
+     */
+    public function arguments(): array
+    {
+        return $this->arguments;
+    }
+
+    public function instantiate(): object
+    {
+        return new ($this->class->type()->className())(...$this->arguments);
+    }
+}

src/Definition/Attributes.php

@@ -6,24 +6,76 @@
 
 use Countable;
 use IteratorAggregate;
+use Traversable;
+
+use function array_filter;
+use function count;
+use function is_a;
 
 /**
  * @internal
  *
- * @extends IteratorAggregate<object>
+ * @implements IteratorAggregate<AttributeDefinition>
  */
-interface Attributes extends IteratorAggregate, Countable
+final class Attributes implements IteratorAggregate, Countable
 {
+    private static self $empty;
+
+    /** @var list<AttributeDefinition> */
+    private array $attributes;
+
+    /**
+     * @no-named-arguments
+     */
+    public function __construct(AttributeDefinition ...$attributes)
+    {
+        $this->attributes = $attributes;
+    }
+
+    public static function empty(): self
+    {
+        return self::$empty ??= new self();
+    }
+
+    public function has(string $className): bool
+    {
+        foreach ($this->attributes as $attribute) {
+            if (is_a($attribute->class()->type()->className(), $className, true)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param callable(AttributeDefinition): bool $callback
+     */
+    public function filter(callable $callback): self
+    {
+        return new self(
+            ...array_filter($this->attributes, $callback)
+        );
+    }
+
+    public function count(): int
+    {
+        return count($this->attributes);
+    }
+
     /**
-     * @param class-string $className
+     * @return list<AttributeDefinition>
      */
-    public function has(string $className): bool;
+    public function toArray(): array
+    {
+        return $this->attributes;
+    }
 
     /**
-     * @template T of object
-     *
-     * @param class-string<T> $className
-     * @return list<T>
+     * @return Traversable<AttributeDefinition>
      */
-    public function ofType(string $className): array;
+    public function getIterator(): Traversable
+    {
+        yield from $this->attributes;
+    }
 }

src/Definition/Repository/AttributesRepository.php

@@ -4,18 +4,14 @@
 
 namespace CuyZ\Valinor\Definition\Repository;
 
-use CuyZ\Valinor\Definition\Attributes;
-use ReflectionClass;
-use ReflectionFunction;
-use ReflectionMethod;
-use ReflectionParameter;
-use ReflectionProperty;
+use CuyZ\Valinor\Definition\AttributeDefinition;
+use ReflectionAttribute;
 
 /** @internal */
 interface AttributesRepository
 {
     /**
-     * @param ReflectionClass<object>|ReflectionProperty|ReflectionMethod|ReflectionFunction|ReflectionParameter $reflector
+     * @param ReflectionAttribute<object> $reflection
      */
-    public function for(ReflectionClass|ReflectionProperty|ReflectionMethod|ReflectionFunction|ReflectionParameter $reflector): Attributes;
+    public function for(ReflectionAttribute $reflection): AttributeDefinition;
 }

src/Definition/Repository/Cache/Compiler/AttributesCompiler.php

@@ -5,8 +5,6 @@
 namespace CuyZ\Valinor\Definition\Repository\Cache\Compiler;
 
 use CuyZ\Valinor\Definition\Attributes;
-use CuyZ\Valinor\Definition\AttributesContainer;
-use CuyZ\Valinor\Definition\NativeAttributes;
 
 use function count;
 use function implode;
@@ -17,29 +15,35 @@
 /** @internal */
 final class AttributesCompiler
 {
+    public function __construct(private ClassDefinitionCompiler $classDefinitionCompiler) {}
+
     public function compile(Attributes $attributes): string
     {
         if (count($attributes) === 0) {
-            return AttributesContainer::class . '::empty()';
+            return Attributes::class . '::empty()';
         }
 
-        assert($attributes instanceof NativeAttributes);
-
-        $attributesListCode = $this->compileNativeAttributes($attributes);
+        $attributesListCode = $this->compileAttributes($attributes);
 
         return <<<PHP
-            new \CuyZ\Valinor\Definition\AttributesContainer($attributesListCode)
+            new \CuyZ\Valinor\Definition\Attributes($attributesListCode)
             PHP;
     }
 
-    private function compileNativeAttributes(NativeAttributes $attributes): string
+    private function compileAttributes(Attributes $attributes): string
     {
         $attributesListCode = [];
 
-        foreach ($attributes->definition() as $className => $arguments) {
-            $argumentsCode = $this->compileAttributeArguments($arguments);
+        foreach ($attributes as $attribute) {
+            $class = $this->classDefinitionCompiler->compile($attribute->class());
+            $arguments = $this->compileAttributeArguments($attribute->arguments());
 
-            $attributesListCode[] = "['class' => '$className', 'callback' => fn () => new $className($argumentsCode)]";
+            $attributesListCode[] = <<<PHP
+            new \CuyZ\Valinor\Definition\AttributeDefinition(
+                $class,
+                [$arguments],
+            )
+            PHP;
         }
 
         return implode(', ', $attributesListCode);

src/Definition/Repository/Cache/Compiler/ClassDefinitionCompiler.php

@@ -28,7 +28,7 @@ final class ClassDefinitionCompiler implements CacheCompiler
     public function __construct()
     {
         $this->typeCompiler = new TypeCompiler();
-        $this->attributesCompiler = new AttributesCompiler();
+        $this->attributesCompiler = new AttributesCompiler($this);
 
         $this->methodCompiler = new MethodDefinitionCompiler($this->typeCompiler, $this->attributesCompiler);
         $this->propertyCompiler = new PropertyDefinitionCompiler($this->typeCompiler, $this->attributesCompiler);

src/Definition/Repository/Cache/Compiler/FunctionDefinitionCompiler.php

@@ -22,9 +22,9 @@ final class FunctionDefinitionCompiler implements CacheCompiler
     public function __construct()
     {
         $this->typeCompiler = new TypeCompiler();
-        $this->attributesCompiler = new AttributesCompiler();
+        $this->attributesCompiler = new AttributesCompiler(new ClassDefinitionCompiler());
 
-        $this->parameterCompiler = new ParameterDefinitionCompiler($this->typeCompiler, new AttributesCompiler());
+        $this->parameterCompiler = new ParameterDefinitionCompiler($this->typeCompiler, $this->attributesCompiler);
     }
 
     public function compile(mixed $value): string