Implement ParameterAttributeCollector

README.md

@@ -59,6 +59,11 @@ foreach (Attributes::findTargetProperties(Column::class) as $target) {
     var_dump($target->attribute, $target->class, $target->name);
 }
 
+// Find the target method-parameters of the UserInput attribute.
+foreach (Attributes::findTargetMethodParameters(UserInput::class) as $target) {
+    var_dump($target->attribute, $target->class, $target->method, $target->name);
+}
+
 // Filter target methods using a predicate.
 // You can also filter target classes and properties.
 $predicate = fn($attribute) => is_a($attribute, Route::class, true);

src/Attributes.php

@@ -61,6 +61,18 @@ public static function findTargetProperties(string $attribute): array
         return self::getCollection()->findTargetProperties($attribute);
     }
 
+    /**
+     * @template T of object
+     *
+     * @param class-string<T> $attribute
+     *
+     * @return TargetMethodParameter<T>[]
+     */
+    public static function findTargetMethodParameters(string $attribute): array
+    {
+        return self::getCollection()->findTargetMethodParameters($attribute);
+    }
+
     /**
      * @param callable(class-string $attribute, class-string $class):bool $predicate
      *
@@ -91,6 +103,16 @@ public static function filterTargetProperties(callable $predicate): array
         return self::getCollection()->filterTargetProperties($predicate);
     }
 
+    /**
+     * @param callable(class-string $attribute, class-string $class, string $property, string $method):bool $predicate
+     *
+     * @return array<TargetMethodParameter<object>>
+     */
+    public static function filterTargetMethodParameters(callable $predicate): array
+    {
+        return self::getCollection()->filterTargetMethodParameters($predicate);
+    }
+
     /**
      * @param class-string $class
      *

src/ClassAttributeCollector.php

@@ -25,6 +25,7 @@ public function __construct(
      *     array<TransientTargetClass>,
      *     array<TransientTargetMethod>,
      *     array<TransientTargetProperty>,
+     *     array<array<TransientTargetMethodParameter>>,
      * }
      *
      * @throws ReflectionException
@@ -34,7 +35,7 @@ public function collectAttributes(string $class): array
         $classReflection = new ReflectionClass($class);
 
         if (self::isAttribute($classReflection)) {
-            return [ [], [], [] ];
+            return [ [], [], [], [] ];
         }
 
         $classAttributes = [];
@@ -54,23 +55,15 @@ public function collectAttributes(string $class): array
         }
 
         $methodAttributes = [];
+        $methodParameterAttributes = [];
 
         foreach ($classReflection->getMethods() as $methodReflection) {
-            foreach ($methodReflection->getAttributes() as $attribute) {
-                if (self::isAttributeIgnored($attribute)) {
-                    continue;
-                }
-
-                $method = $methodReflection->name;
-
-                $this->io->debug("Found attribute {$attribute->getName()} on $class::$method");
-
-                $methodAttributes[] = new TransientTargetMethod(
-                    $attribute->getName(),
-                    $attribute->getArguments(),
-                    $method,
-                );
-            }
+            $this->collectMethodAndParameterAttributes(
+                $class,
+                $methodReflection,
+                $methodAttributes,
+                $methodParameterAttributes,
+            );
         }
 
         $propertyAttributes = [];
@@ -94,7 +87,7 @@ public function collectAttributes(string $class): array
             }
         }
 
-        return [ $classAttributes, $methodAttributes, $propertyAttributes ];
+        return [ $classAttributes, $methodAttributes, $propertyAttributes, $methodParameterAttributes ];
     }
 
     /**
@@ -124,4 +117,34 @@ private static function isAttributeIgnored(ReflectionAttribute $attribute): bool
 
         return isset($ignored[$attribute->getName()]); // @phpstan-ignore offsetAccess.nonOffsetAccessible
     }
+
+    /**
+     * @param array<TransientTargetMethod> $methodAttributes
+     * @param array<array<TransientTargetMethodParameter>> $methodParameterAttributes
+     * @return void
+     */
+    private function collectMethodAndParameterAttributes(string $class, \ReflectionMethod $methodReflection, array &$methodAttributes, array &$methodParameterAttributes): void
+    {
+        $parameterAttributeCollector = new ParameterAttributeCollector($this->io);
+        foreach ($methodReflection->getAttributes() as $attribute) {
+            if (self::isAttributeIgnored($attribute)) {
+                continue;
+            }
+
+            $method = $methodReflection->name;
+
+            $this->io->debug("Found attribute {$attribute->getName()} on $class::$method");
+
+            $methodAttributes[] = new TransientTargetMethod(
+                $attribute->getName(),
+                $attribute->getArguments(),
+                $method,
+            );
+        }
+
+        $parameterAttributes = $parameterAttributeCollector->collectAttributes($methodReflection);
+        if ($parameterAttributes !== []) {
+            $methodParameterAttributes[] = $parameterAttributes;
+        }
+    }
 }

src/Collection.php

@@ -22,11 +22,15 @@ final class Collection
      * @param array<class-string, array<array{ mixed[], class-string, non-empty-string }>> $targetProperties
      *     Where _key_ is an attribute class and _value_ an array of arrays
      *     where 0 are the attribute arguments, 1 is a target class, and 2 is the target property.
+     * @param array<class-string, array<array{ mixed[], class-string, non-empty-string, non-empty-string }>> $targetMethodParameters
+     *     Where _key_ is an attribute class and _value_ an array of arrays
+     *     where 0 are the attribute arguments, 1 is a target class, 2 is the target method, and 3 is the target parameter.
      */
     public function __construct(
         private array $targetClasses,
         private array $targetMethods,
         private array $targetProperties,
+        private array $targetMethodParameters,
     ) {
     }
 
@@ -109,6 +113,46 @@ private static function createMethodAttribute(
         }
     }
 
+    /**
+     * @template T of object
+     *
+     * @param class-string<T> $attribute
+     *
+     * @return array<TargetMethodParameter<T>>
+     */
+    public function findTargetMethodParameters(string $attribute): array
+    {
+        return array_map(
+            fn(array $t) => self::createMethodParameterAttribute($attribute, ...$t),
+            $this->targetMethodParameters[$attribute] ?? [],
+        );
+    }
+
+    /**
+     * @template T of object
+     *
+     * @param class-string<T> $attribute
+     * @param array<mixed> $arguments
+     * @param class-string $class
+     * @param non-empty-string $method
+     * @param non-empty-string $parameter
+     *
+     * @return TargetMethodParameter<T>
+     */
+    private static function createMethodParameterAttribute(string $attribute, array $arguments, string $class, string $method, string $parameter): object
+    {
+        try {
+            $a = new $attribute(...$arguments);
+            return new TargetMethodParameter($a, $class, $method, $parameter);
+        } catch (Throwable $e) {
+            throw new RuntimeException(
+                "An error occurred while instantiating attribute $attribute on method $class::$method($parameter)",
+                0,
+                $e,
+            );
+        }
+    }
+
     /**
      * @template T of object
      *
@@ -196,6 +240,32 @@ public function filterTargetMethods(callable $predicate): array
         return $ar;
     }
 
+    /**
+     * @param callable(class-string $attribute, class-string $class, non-empty-string $method, non-empty-string $parameter):bool $predicate
+     *
+     * @return array<TargetMethodParameter<object>>
+     */
+    public function filterTargetMethodParameters(callable $predicate): array
+    {
+        $ar = [];
+
+        foreach ($this->targetMethodParameters as $attribute => $references) {
+            foreach ($references as [$arguments, $class, $method, $parameter]) {
+                if ($predicate($attribute, $class, $method, $parameter)) {
+                    $ar[] = self::createMethodParameterAttribute(
+                        $attribute,
+                        $arguments,
+                        $class,
+                        $method,
+                        $parameter
+                    );
+                }
+            }
+        }
+
+        return $ar;
+    }
+
     /**
      * @param callable(class-string $attribute, class-string $class, non-empty-string $property):bool $predicate
      *

src/MemoizeAttributeCollector.php

@@ -23,12 +23,14 @@ class MemoizeAttributeCollector
      *     array<TransientTargetClass>,
      *     array<TransientTargetMethod>,
      *     array<TransientTargetProperty>,
+     *     array<array<TransientTargetMethodParameter>>,
      * }>
      *     Where _key_ is a class and _value is an array where:
      *     - `0` is a timestamp
      *     - `1` is an array of class attributes
      *     - `2` is an array of method attributes
      *     - `3` is an array of property attributes
+     *     - `4` is an array of arrays. _key_ is a method name and _value_ parameter attributes
      */
     private array $state;
 
@@ -59,7 +61,8 @@ public function collectAttributes(array $classMap): TransientCollection
                 $classAttributes,
                 $methodAttributes,
                 $propertyAttributes,
-            ] = $this->state[$class] ?? [ 0, [], [], [] ];
+                $methodParameterAttributes,
+            ] = $this->state[$class] ?? [ 0, [], [], [], [] ];
 
             $mtime = filemtime($filepath);
 
@@ -76,14 +79,15 @@ public function collectAttributes(array $classMap): TransientCollection
                         $classAttributes,
                         $methodAttributes,
                         $propertyAttributes,
+                        $methodParameterAttributes,
                     ] = $classAttributeCollector->collectAttributes($class);
                 } catch (Throwable $e) {
                     $this->io->error(
                         "Attribute collection failed for $class: {$e->getMessage()}",
                     );
                 }
 
-                $this->state[$class] = [ time(), $classAttributes, $methodAttributes, $propertyAttributes ];
+                $this->state[$class] = [ time(), $classAttributes, $methodAttributes, $propertyAttributes, $methodParameterAttributes ];
             }
 
             if (count($classAttributes)) {
@@ -92,6 +96,9 @@ public function collectAttributes(array $classMap): TransientCollection
             if (count($methodAttributes)) {
                 $collector->addMethodAttributes($class, $methodAttributes);
             }
+            if (count($methodParameterAttributes)) {
+                $collector->addMethodParameterAttributes($class, $methodParameterAttributes);
+            }
             if (count($propertyAttributes)) {
                 $collector->addTargetProperties($class, $propertyAttributes);
             }

src/ParameterAttributeCollector.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace olvlvl\ComposerAttributeCollector;
+
+use Composer\IO\IOInterface;
+use PhpParser\Node;
+use PhpParser\Node\Stmt\ClassLike;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitorAbstract;
+use PhpParser\Parser;
+
+/**
+ * @internal
+ */
+class ParameterAttributeCollector
+{
+    public function __construct(
+        private IOInterface $io
+    ) {
+    }
+
+    /**
+     * @return array<TransientTargetMethodParameter>
+     */
+    public function collectAttributes(\ReflectionFunctionAbstract $reflectionFunctionAbstract): array
+    {
+        $funcParameterAttributes = [];
+        foreach ($reflectionFunctionAbstract->getParameters() as $parameter) {
+            $attributes = $parameter->getAttributes();
+            $functionName = $reflectionFunctionAbstract->name;
+            $parameterName = $parameter->name;
+            assert($functionName !== '');
+            assert($parameterName !== '');
+
+            $paramLabel = '';
+            if ($reflectionFunctionAbstract instanceof \ReflectionMethod) {
+                $paramLabel = $reflectionFunctionAbstract->class . '::' . $functionName . '(' . $parameterName . ')';
+            } elseif ($reflectionFunctionAbstract instanceof \ReflectionFunction) {
+                $paramLabel = $functionName . '(' . $parameterName . ')';
+            }
+
+            foreach ($attributes as $attribute) {
+                $this->io->debug("Found attribute {$attribute->getName()} on $paramLabel");
+
+                $funcParameterAttributes[] = new TransientTargetMethodParameter(
+                    $attribute->getName(),
+                    $attribute->getArguments(),
+                    $functionName,
+                    $parameterName
+                );
+            }
+        }
+
+        return $funcParameterAttributes;
+    }
+}

src/Plugin.php

@@ -27,7 +27,7 @@ final class Plugin implements PluginInterface, EventSubscriberInterface
 {
     public const CACHE_DIR = '.composer-attribute-collector';
     public const VERSION_MAJOR = 2;
-    public const VERSION_MINOR = 0;
+    public const VERSION_MINOR = 1;
 
     /**
      * @uses onPostAutoloadDump

src/TargetMethodParameter.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace olvlvl\ComposerAttributeCollector;
+
+/**
+ * @readonly
+ *
+ * @template T of object
+ */
+final class TargetMethodParameter
+{
+    /**
+     * @param T $attribute
+     * @param class-string $class
+     *     The name of the target class.
+     * @param non-empty-string $name
+     *     The name of the target parameter.
+     * @param non-empty-string $method
+     *      The name of the target method.
+     */
+    public function __construct(
+        public object $attribute,
+        public string $class,
+        public string $name,
+        public string $method
+    ) {
+    }
+}