Extract PropertyResolver strategy

Previously, the resolution of validators from property types and explicit
new resolution strategies required editing the class, and a class-typed
property annotated with #[Attributes] was validated twice — once by the
explicit-attribute branch and again by the declared-type branch — which
tripped the circular-reference guard on the second pass.

This commit moves that responsibility to a dedicated PropertyResolver
interface with composable implementations, so each strategy can be
developed and composed independently. The composite collapses duplicate
Attributes entries, ensuring each property is validated exactly once
even when multiple resolution paths produce the same instance. The
Attributes class is reduced to its single responsibility, and resolver
chains become pluggable through the constructor.

Author: henriquemoody

docs/validators/Attributes.md

@@ -8,6 +8,7 @@ SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
 # Attributes
 
 - `Attributes()`
+- `Attributes(PropertyResolver $propertyResolver)`
 
 Validates the PHP attributes defined in the properties of the input.
 

src-dev/Commands/LintMixinCommand.php

@@ -22,6 +22,7 @@
 use Respect\Validation\Mixins\Chain;
 use Respect\Validation\Validator;
 use Respect\Validation\ValidatorBuilder;
+use Respect\Validation\Validators\Attributes\PropertyResolver;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
@@ -75,7 +76,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
             scanner: $scanner,
             methodBuilder: new MethodBuilder(
                 excludedTypePrefixes: ['Sokil', 'Egulias'],
-                excludedTypeNames: ['finfo'],
+                excludedTypeNames: ['finfo', PropertyResolver::class],
             ),
             interfaces: [
                 new InterfaceConfig(

src/Validators/Attributes.php

@@ -15,16 +15,17 @@
 use Attribute;
 use ReflectionAttribute;
 use ReflectionClass;
-use ReflectionIntersectionType;
-use ReflectionNamedType;
 use ReflectionObject;
 use ReflectionProperty;
-use ReflectionUnionType;
 use Respect\Fluent\Attributes\Composable;
 use Respect\Validation\Id;
 use Respect\Validation\Message\Template;
 use Respect\Validation\Result;
 use Respect\Validation\Validator;
+use Respect\Validation\Validators\Attributes\CompositePropertyResolver;
+use Respect\Validation\Validators\Attributes\DeclaredTypePropertyResolver;
+use Respect\Validation\Validators\Attributes\ExplicitAttributePropertyResolver;
+use Respect\Validation\Validators\Attributes\PropertyResolver;
 use Respect\Validation\Validators\Core\Reducer;
 
 use function spl_object_id;
@@ -43,6 +44,17 @@ final class Attributes implements Validator
     /** @var array<int, true> */
     private array $visited = [];
 
+    private readonly PropertyResolver $propertyResolver;
+
+    public function __construct(
+        PropertyResolver|null $propertyResolver = null,
+    ) {
+        $this->propertyResolver = $propertyResolver ?? new CompositePropertyResolver(
+            new ExplicitAttributePropertyResolver(),
+            new DeclaredTypePropertyResolver(),
+        );
+    }
+
     public function evaluate(mixed $input): Result
     {
         $id = new Id('attributes');
@@ -87,7 +99,7 @@ private function getPropertyValidators(ReflectionObject $reflection): array
     {
         $validators = [];
         foreach ($this->getProperties($reflection) as $propertyName => $property) {
-            $propertyValidators = $this->getPropertyInnerValidators($property);
+            $propertyValidators = $this->propertyResolver->resolve($property, $this);
             if ($propertyValidators === []) {
                 continue;
             }
@@ -101,47 +113,6 @@ private function getPropertyValidators(ReflectionObject $reflection): array
         return $validators;
     }
 
-    /** @return array<Validator> */
-    private function getPropertyInnerValidators(ReflectionProperty $property): array
-    {
-        $propertyValidators = [];
-        $hasExplicitAttributes = false;
-        foreach ($property->getAttributes(Validator::class, ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
-            $propertyValidator = $attribute->getName() === self::class ? $this : $attribute->newInstance();
-            $hasExplicitAttributes = $propertyValidator === $this;
-            $propertyValidators[] = $propertyValidator;
-        }
-
-        if ($hasExplicitAttributes) {
-            return $propertyValidators;
-        }
-
-        $type = $property->getType();
-        if ($type instanceof ReflectionNamedType) {
-            if (!$type->isBuiltin()) {
-                $propertyValidators[] = $this;
-            }
-        }
-
-        if ($type instanceof ReflectionIntersectionType) {
-            $propertyValidators[] = $this;
-        }
-
-        if ($type instanceof ReflectionUnionType) {
-            foreach ($type->getTypes() as $innerType) {
-                if (!$innerType instanceof ReflectionNamedType || $innerType->isBuiltin()) {
-                    continue;
-                }
-
-                /** @var class-string $class */
-                $class = $innerType->getName();
-                $propertyValidators[] = new Given(new Instance($class), $this);
-            }
-        }
-
-        return $propertyValidators;
-    }
-
     /** @return array<ReflectionProperty> */
     private function getProperties(ReflectionObject $reflection): array
     {

src/Validators/Attributes/CompositePropertyResolver.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Validators\Attributes;
+
+use ReflectionProperty;
+use Respect\Validation\Validator;
+use Respect\Validation\Validators\Attributes;
+
+use function array_values;
+use function in_array;
+
+final class CompositePropertyResolver implements PropertyResolver
+{
+    /** @var list<PropertyResolver> */
+    private readonly array $resolvers;
+
+    public function __construct(PropertyResolver ...$resolvers)
+    {
+        $this->resolvers = array_values($resolvers);
+    }
+
+    /** @return array<Validator> */
+    public function resolve(ReflectionProperty $property, Attributes $attributes): array
+    {
+        $accumulated = [];
+
+        foreach ($this->resolvers as $resolver) {
+            $validators = $resolver->resolve($property, $attributes);
+            if ($validators === []) {
+                continue;
+            }
+
+            // When more than one resolver recognizes the same property (e.g. a
+            // class-typed property annotated with #[Attributes], which both
+            // DeclaredTypePropertyResolver and ExplicitAttributePropertyResolver
+            // emit `$attributes` for), collapse duplicate `$attributes` entries
+            // so the nested Attributes validator runs once instead of tripping
+            // its circular-reference guard on the second pass.
+            foreach ($validators as $validator) {
+                if ($validator === $attributes && in_array($validator, $accumulated, true)) {
+                    continue;
+                }
+
+                $accumulated[] = $validator;
+            }
+        }
+
+        return $accumulated;
+    }
+}

src/Validators/Attributes/DeclaredTypePropertyResolver.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Validators\Attributes;
+
+use ReflectionIntersectionType;
+use ReflectionNamedType;
+use ReflectionProperty;
+use ReflectionUnionType;
+use Respect\Validation\Validator;
+use Respect\Validation\Validators\Attributes;
+use Respect\Validation\Validators\Given;
+use Respect\Validation\Validators\Instance;
+
+final class DeclaredTypePropertyResolver implements PropertyResolver
+{
+    /** @return array<Validator> */
+    public function resolve(ReflectionProperty $property, Attributes $attributes): array
+    {
+        $type = $property->getType();
+
+        if ($type instanceof ReflectionNamedType) {
+            if ($type->isBuiltin()) {
+                return [];
+            }
+
+            return [$attributes];
+        }
+
+        if ($type instanceof ReflectionIntersectionType) {
+            return [$attributes];
+        }
+
+        if ($type instanceof ReflectionUnionType) {
+            $validators = [];
+            foreach ($type->getTypes() as $innerType) {
+                if (!$innerType instanceof ReflectionNamedType || $innerType->isBuiltin()) {
+                    continue;
+                }
+
+                /** @var class-string $class */
+                $class = $innerType->getName();
+                $validators[] = new Given(new Instance($class), $attributes);
+            }
+
+            return $validators;
+        }
+
+        return [];
+    }
+}

src/Validators/Attributes/ExplicitAttributePropertyResolver.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Validators\Attributes;
+
+use ReflectionAttribute;
+use ReflectionProperty;
+use Respect\Validation\Validator;
+use Respect\Validation\Validators\Attributes;
+
+final class ExplicitAttributePropertyResolver implements PropertyResolver
+{
+    /** @return array<Validator> */
+    public function resolve(ReflectionProperty $property, Attributes $attributes): array
+    {
+        $validators = [];
+        foreach ($property->getAttributes(Validator::class, ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
+            $propertyValidator = $attribute->getName() === Attributes::class ? $attributes : $attribute->newInstance();
+            $validators[] = $propertyValidator;
+        }
+
+        return $validators;
+    }
+}

src/Validators/Attributes/PropertyResolver.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Validators\Attributes;
+
+use ReflectionProperty;
+use Respect\Validation\Validator;
+use Respect\Validation\Validators\Attributes;
+
+/**
+ * Resolves validators from properties.
+ */
+interface PropertyResolver
+{
+    /** @return array<Validator> */
+    public function resolve(ReflectionProperty $property, Attributes $attributes): array;
+}

tests/src/Stubs/StubPropertyResolver.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Test\Stubs;
+
+use ReflectionProperty;
+use Respect\Validation\Validator;
+use Respect\Validation\Validators\Attributes;
+use Respect\Validation\Validators\Attributes\PropertyResolver;
+
+use function array_values;
+
+final class StubPropertyResolver implements PropertyResolver
+{
+    /** @var list<Validator> */
+    private readonly array $validators;
+
+    public function __construct(Validator ...$validators)
+    {
+        $this->validators = array_values($validators);
+    }
+
+    /** @return list<Validator> */
+    public function resolve(ReflectionProperty $property, Attributes $attributes): array
+    {
+        return $this->validators;
+    }
+}

tests/src/Stubs/WithClassTypedProperty.php

@@ -0,0 +1,19 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Test\Stubs;
+
+final class WithClassTypedProperty
+{
+    public function __construct(
+        public NestedAddress $value,
+    ) {
+    }
+}

tests/src/Stubs/WithExplicitAttributesAttributeProperty.php

@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: (c) Respect Project Contributors
+ * SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Test\Stubs;
+
+use Respect\Validation\Validators as Rule;
+
+final class WithExplicitAttributesAttributeProperty
+{
+    public function __construct(
+        #[Rule\Attributes]
+        public NestedAddress $address,
+    ) {
+    }
+}