Add @DependencyInjection annotation

Author: smarx-shopmacher

README.MD

@@ -199,4 +199,47 @@ class AnotherChild extends MyParent {}
  */
 class SomeChild extends MyParent {}
 
+```
+
+
+#### Example 5: DependencyInjection via Annotation
+
+In case you want to inject something from your container into the constructor (e.g. tagged_iterator) which is not handled by autowiring
+you can use the `@DependencyInjection` annotation.
+
+```php
+<?php
+
+namespace App;
+
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\DependencyInjection;
+
+class SomeClass {
+    /**
+     * The annotation also works for public properties injection
+     * 
+     * @DependencyInjection(serviceId="my_service")
+     */
+    public SomeInterface $service;
+
+    /**
+     * if you have more than one argument in constructor use "target" to identify which argument should get the injection
+     *
+     * @DependencyInjection(target="handlers", tagged="your_tag_id")
+     * @DependencyInjection(target="anotherService", serviceId="some_service")
+     */
+    public function __construct(SomeAutowiredService $service, iterable $handlers, SomeService $anotherService) {
+        
+    }   
+
+    /**
+     * if you have only one argument in your constructor there is no need for the "target" option
+     *
+     * @DependencyInjection(tagged="your_tag_id")
+     */
+    public function __construct(iterable $handlers) {
+        
+    }   
+}
+
 ```

SimaServiceAnnotationsBundle.php

@@ -4,6 +4,7 @@
 namespace SimonMarx\Symfony\Bundles\ServiceAnnotations;
 
 
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\DependencyInjectionPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\NoServicePass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceAliasPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceTagArgumentPass;
@@ -22,6 +23,6 @@ public function build(ContainerBuilder $container)
             ->addCompilerPass(new ServiceAliasPass())
             ->addCompilerPass(new ServiceTagArgumentPass())
             ->addCompilerPass(new NoServicePass())
-        ;
+            ->addCompilerPass(new DependencyInjectionPass());
     }
 }

Utils/CompilerPassServiceAnnotationTrait.php

@@ -11,6 +11,7 @@
 use Doctrine\Common\Annotations\AnnotationReader;
 use ReflectionClass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\IgnoreParentServiceAnnotations;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Struct\ClassAnnotationScan;
 use Symfony\Component\DependencyInjection\Definition;
 
 trait CompilerPassServiceAnnotationTrait
@@ -21,9 +22,12 @@ trait CompilerPassServiceAnnotationTrait
 
     private array $annotationCache = [];
 
+    private array $fullScanCache = [];
+
     public function __construct()
     {
         $this->annotationReader = new AnnotationReader();
+        AnnotationReader::addGlobalIgnoredName('required');
     }
 
     private function definitionHasValidClass(Definition $definition): bool
@@ -64,10 +68,10 @@ private function warmupDefinitionAnnotationCache(Definition $definition): void
             return;
         }
 
-        $this->annotationCache[$cacheKey] = $this->crawlAnnotationsRecursive($rc);
+        $this->annotationCache[$cacheKey] = $this->crawlClassAnnotationsRecursive($rc);
     }
 
-    private function crawlAnnotationsRecursive(ReflectionClass $reflectionClass): array
+    private function crawlClassAnnotationsRecursive(ReflectionClass $reflectionClass): array
     {
         $annotations = $this->annotationReader->getClassAnnotations($reflectionClass);
         $ignored = $this->annotationReader->getClassAnnotation($reflectionClass, IgnoreParentServiceAnnotations::class);
@@ -79,7 +83,7 @@ private function crawlAnnotationsRecursive(ReflectionClass $reflectionClass): ar
                 || $reflectionClass->getParentClass()->isInterface()
             )
         ) {
-            $parentAnnotations = $this->crawlAnnotationsRecursive($reflectionClass->getParentClass());
+            $parentAnnotations = $this->crawlClassAnnotationsRecursive($reflectionClass->getParentClass());
 
             if ($ignored instanceof IgnoreParentServiceAnnotations) {
                 foreach ($parentAnnotations as $parentAnnotation) {
@@ -93,7 +97,7 @@ private function crawlAnnotationsRecursive(ReflectionClass $reflectionClass): ar
         }
 
         foreach ($reflectionClass->getInterfaces() as $interface) {
-            $interfaceAnnotations = $this->crawlAnnotationsRecursive($interface);
+            $interfaceAnnotations = $this->crawlClassAnnotationsRecursive($interface);
 
             if ($ignored instanceof IgnoreParentServiceAnnotations) {
                 foreach ($interfaceAnnotations as $interfaceAnnotation) {
@@ -135,4 +139,15 @@ private function getDefinitionAnnotations(Definition $definition): array
 
         return $this->annotationCache[$cacheKey] ?? [];
     }
+
+    private function fullAnnotationScan(Definition $definition): ClassAnnotationScan
+    {
+        $cacheKey = $this->getDefinitionCacheKey($definition);
+
+        if (false === \array_key_exists($cacheKey, $this->fullScanCache)) {
+            $this->fullScanCache[$cacheKey] = new ClassAnnotationScan($definition->getClass());
+        }
+
+        return $this->fullScanCache[$cacheKey];
+    }
 }

Utils/ReflectionCacheTrait.php

@@ -4,25 +4,58 @@
 namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils;
 
 
+use App\Command\PermissionPersistCommand;
 use ReflectionClass;
 use ReflectionException;
+use ReflectionMethod;
+use ReflectionProperty;
 
 trait ReflectionCacheTrait
 {
-    private array $classCache = [];
+    private array $classReflectionCache = [];
 
     private function getClassReflection(string $className): ?ReflectionClass
     {
-        $hashKey = md5($className);
+        $cacheKey = \md5($className);
 
-        if (false === \array_key_exists($hashKey, $this->classCache)) {
+        if (false === \array_key_exists($cacheKey, $this->classReflectionCache)) {
             try {
-                $this->classCache[$hashKey] = new ReflectionClass($className);
+                $this->classReflectionCache[$cacheKey] = new ReflectionClass($className);
             } catch (ReflectionException $reflectionException) {
                 return null;
             }
         }
 
-        return $this->classCache[$hashKey] ?? null;
+        return $this->classReflectionCache[$cacheKey] ?? null;
+    }
+
+    public function getMethodReflection(string $className, string $methodName): ?ReflectionMethod
+    {
+        $rc = $this->getClassReflection($className);
+
+        if (null === $rc) {
+            return null;
+        }
+
+        try {
+            return $rc->getMethod($methodName);
+        } catch (ReflectionException $exception) {
+            return null;
+        }
+    }
+
+    public function getPropertyReflection(string $className, string $propertyName): ?ReflectionProperty
+    {
+        $rc = $this->getClassReflection($className);
+
+        if (null === $rc) {
+            return null;
+        }
+
+        try {
+            return $rc->getProperty($propertyName);
+        } catch (ReflectionException $exception) {
+            return null;
+        }
     }
 }