Add multiple service annotations

smarx-shopmacher · smarx-shopmacher · commit 1bda826ec917 · 2020-11-17T15:58:25.000+01:00
diff --git a/Annotation/DependencyInjection.php b/Annotation/DependencyInjection.php
@@ -16,12 +16,14 @@ class DependencyInjection
     private ?string $serviceId = null;
     private ?string $target = null;
     private ?string $tagged = null;
+    private ?string $parameter = null;
 
     public function __construct(array $values = [])
     {
         $this->serviceId = $values['serviceId'] ?? $values['value'] ?? null;
         $this->target = $values['target'] ?? null;
         $this->tagged = $values['tagged'] ?? null;
+        $this->parameter = $values['parameter'] ?? null;
     }
 
     public function setServiceId(string $serviceId): void
@@ -47,6 +49,11 @@ public function setTarget(string $target): void
         $this->target = $target;
     }
 
+    public function getParameter(): ?string
+    {
+        return $this->parameter;
+    }
+
     public function getTarget(): ?string
     {
         return $this->target;
diff --git a/Annotation/ServiceTag.php b/Annotation/ServiceTag.php
@@ -13,13 +13,11 @@
 class ServiceTag
 {
     private string $name;
-    private ?int $priority = null;
     private array $attributes = [];
 
     public function __construct(array $values = [])
     {
         $this->name = $values['name'] ?? $values['value'];
-        $this->priority = $values['priority'] ?? null;
 
         if (\array_key_exists('value', $values)) {
             unset($values['value']);
@@ -35,11 +33,6 @@ public function getName(): string
         return $this->name;
     }
 
-    public function getPriority(): ?int
-    {
-        return $this->priority ?: $this->getAttributes()['priority'] ?? null;
-    }
-
     public function getAttributes(): array
     {
         return $this->attributes;
diff --git a/DependencyInjection/Compiler/DependencyInjectionPass.php b/DependencyInjection/Compiler/DependencyInjectionPass.php
@@ -21,8 +21,12 @@ class DependencyInjectionPass implements CompilerPassInterface
     use CompilerPassServiceAnnotationTrait;
     use ReflectionCacheTrait;
 
+    private ContainerBuilder $container;
+
     public function process(ContainerBuilder $container)
     {
+        $this->container = $container;
+
         foreach ($container->getDefinitions() as $definition) {
             if (false === $this->definitionHasValidClass($definition)) {
                 continue;
@@ -35,6 +39,11 @@ public function process(ContainerBuilder $container)
         }
     }
 
+    private function findParameter(string $name)
+    {
+        return $this->container->getParameter($name);
+    }
+
     private function handlePropertyAnnotations(ClassAnnotationScan $annotationScan, Definition $definition)
     {
         /**
@@ -55,15 +64,21 @@ private function handlePropertyAnnotations(ClassAnnotationScan $annotationScan,
             $propertyAnnotation = $propertyAnnotations[0];
 
             if (null === $propertyAnnotation->getServiceId() && null === $propertyAnnotation->getTagged()) {
-                throw new InvalidServiceAnnotationException(\sprintf('Property %s::%s has @DependencyInjection without "serviceId" and "tagged" option. One of them must be defined'));
+                throw new InvalidServiceAnnotationException(\sprintf('Property %s::%s has @DependencyInjection without "serviceId", "tagged" or "parameter" option. One of them must be defined', $property->getDeclaringClass()->getName(), $property->getName()));
             }
 
 
             if (null !== $propertyAnnotation->getServiceId()) {
                 $definition->setProperty($property->getName(), service($propertyAnnotation->getServiceId()));
-            } elseif (null !== $propertyAnnotation->getTagged()) {
+            }
+
+            if (null !== $propertyAnnotation->getTagged()) {
                 $definition->setProperty($property->getName(), tagged_iterator($propertyAnnotation->getTagged()));
             }
+
+            if (null !== $propertyAnnotation->getParameter()) {
+                $definition->setProperty($property->getName(), $this->findParameter($propertyAnnotation->getParameter()));
+            }
         }
     }
 
@@ -96,9 +111,15 @@ private function handleMethodAnnotations(ClassAnnotationScan $annotationScan, De
                 if ($foundTargetAnnotation instanceof DependencyInjection) {
                     if (null !== $foundTargetAnnotation->getServiceId()) {
                         $definition->setArgument(\sprintf('$%s', $parameter->getName()), new Reference($foundTargetAnnotation->getServiceId()));
-                    } elseif (null !== $foundTargetAnnotation->getTagged()) {
+                    }
+
+                    if (null !== $foundTargetAnnotation->getTagged()) {
                         $definition->setArgument(\sprintf('$%s', $parameter->getName()), tagged_iterator($foundTargetAnnotation->getTagged()));
                     }
+
+                    if (null !== $foundTargetAnnotation->getParameter()) {
+                        $definition->setArgument(\sprintf('$%s', $parameter->getName()), $this->findParameter($foundTargetAnnotation->getParameter()));
+                    }
                 }
             }
         }
diff --git a/DependencyInjection/Compiler/ServiceTagArgumentPass.php b/DependencyInjection/Compiler/ServiceTagArgumentPass.php
@@ -4,28 +4,39 @@
 namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler;
 
 
+use App\Serializer\Normalizer\DateTimeNormalizer;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\ServiceTag;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\ServiceTagArgument;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Exception\InvalidServiceAnnotationException;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\CompilerPassServiceAnnotationTrait;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\InstanceOfInjectionTrait;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ObjectCloner;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ObjectClonerContext;
+use Symfony\Component\DependencyInjection\ChildDefinition;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
 
 class ServiceTagArgumentPass implements CompilerPassInterface
 {
     use CompilerPassServiceAnnotationTrait;
+    use InstanceOfInjectionTrait;
 
     public function process(ContainerBuilder $container)
     {
         foreach ($container->getDefinitions() as $serviceId => $definition) {
+            if ($this->checkDefinitionHasInstanceOfConfigurations($container, $definition)) {
+                continue;
+            }
+
             if (false === $this->definitionHasValidClass($definition) || false === $this->definitionHasAnnotation($definition, ServiceTagArgument::class)) {
                 continue;
             }
 
             /** @var ServiceTagArgument[] $arguments */
             $arguments = $this->getDefinitionAnnotations($definition, ServiceTagArgument::class);
-            /** @var ServiceTag[] $serviceTags */
-            $serviceTags = $this->getDefinitionAnnotations($definition, ServiceTag::class);
+            $serviceTags = $definition->getTags();
 
             $attributesByTag = [];
 
@@ -34,45 +45,42 @@ public function process(ContainerBuilder $container)
                     throw new InvalidServiceAnnotationException(\sprintf('Please define in your class "%s" in annotation "@ServiceTagArgument" the property "tag", since you have more than one "@ServiceTag" definitions in your class or parents of your class the system cannot autodetect the service tag for your arguments', $definition->getClass()));
                 }
 
-                $tagName = $tagArgument->getTag() ?: $serviceTags[0]->getName();
-                $tagArgument->setTag($tagName);
+                $tagName = $tagArgument->getTag() ?: \array_keys($serviceTags)[0] ?? null;
 
-                $attributesByTag[$tagName][] = $tagArgument;
-            }
-
-            $definedAttributesByTag = [];
+                if (null === $tagName) {
+                    throw new InvalidServiceAnnotationException(\sprintf('Using annotation "%s" requires that the service definition has tags defined. Your service "%s" does not have any tag defined', ServiceTagArgument::class, $serviceId));
+                }
 
-            foreach ($attributesByTag as $tag => $attributes) {
-                foreach ($definition->getTag($tag) as $tagDefinition) {
-                    $definedAttributesByTag[$tag] = \array_replace($definedAttributesByTag[$tag] ?? [], \array_keys($tagDefinition));
+                if (null === $tagArgument->getTag()) {
+                    $tagArgument->setTag($tagName);
                 }
-            }
 
-            $usedAttributes = [];
+                $attributesByTag[$tagName][] = $tagArgument;
+            }
 
-            /** @var ServiceTagArgument $attribute */
-            foreach ($attributesByTag as $tag => $attributes) {
-                foreach ($attributes as $attribute) {
-                    if (true === \in_array($attribute->getArgument(), $definedAttributesByTag[$tag] ?? []) && true === $attribute->getIgnoreWhenDefined() && true === $attribute->getExceptionWhenDefined()) {
-                        throw new InvalidServiceAnnotationException(\sprintf('Attribute "%s" defined in class "%s" was already defined for tag "%s". Add options "ignoreWhenDefined" to false to overwrite attribute or set option "exceptionWhenDefined" to false to hide the exception and ignore the attribute', $attribute->getArgument(), $definition->getClass(), $attribute->getTag()));
+            $existingDefinitionTags = $definition->getTags();
+
+            /**
+             * @var string $tag
+             * @var ServiceTagArgument[] $serviceTagArguments
+             */
+            foreach ($attributesByTag as $tag => $serviceTagArguments) {
+                foreach ($serviceTagArguments as $serviceTagArgument) {
+                    $tagAttributes = $existingDefinitionTags[$serviceTagArgument->getTag()] ?? [];
+
+                    if (\count($tagAttributes) > 0) {
+                        foreach ($tagAttributes as $index => $attributes) {
+                            $tagAttributes[$index][$serviceTagArgument->getArgument()] = $serviceTagArgument->getValue();
+                        }
+                    } else {
+                        $tagAttributes[0][$serviceTagArgument->getArgument()] = $serviceTagArgument->getValue();
                     }
 
-                    if (
-                        false === \in_array($attribute->getArgument(), $definedAttributesByTag[$tag])
-                        || (
-                            true === \in_array($attribute->getArgument(), $definedAttributesByTag[$tag])
-                            && false === $attribute->getIgnoreWhenDefined()
-                        )
-                    ) {
-                        $usedAttributes[$tag][$attribute->getArgument()] = $attribute->getValue();
-                    }
+                    $existingDefinitionTags[$serviceTagArgument->getTag()] = $tagAttributes;
                 }
             }
 
-
-            foreach($usedAttributes as $tag => $attributes) {
-                $definition->addTag($tag, $attributes);
-            }
+            $definition->setTags($existingDefinitionTags);
         }
     }
 }
diff --git a/DependencyInjection/Compiler/ServiceTagPass.php b/DependencyInjection/Compiler/ServiceTagPass.php
@@ -4,26 +4,46 @@
 namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler;
 
 
+use App\DocReader\AnnotationHandler\RouteAnnotationHandler;
+use App\Event\Doctrine\UserPrePersistListener;
+use App\Serializer\Normalizer\DateTimeNormalizer;
+use App\Service\DocReader\Controller\DocumentationController;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\EventListener;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\ServiceTag;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\CompilerPassServiceAnnotationTrait;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\InstanceOfInjectionTrait;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ReflectionCacheTrait;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
 
 class ServiceTagPass implements CompilerPassInterface
 {
     use ReflectionCacheTrait;
     use CompilerPassServiceAnnotationTrait;
+    use InstanceOfInjectionTrait;
 
     public function process(ContainerBuilder $container)
     {
         foreach ($container->getDefinitions() as $serviceId => $definition) {
-            if (false === $this->definitionHasValidClass($definition) || false === $this->definitionHasAnnotation($definition, ServiceTag::class)) {
+            if (
+                false === $this->definitionHasValidClass($definition)
+                || (
+                    false === $this->definitionHasAnnotation($definition, ServiceTag::class)
+                    && false === $this->definitionHasAnnotation($definition, EventListener::class)
+                )
+            ) {
                 continue;
             }
 
             /** @var ServiceTag[] $tags */
             $tags = $this->getDefinitionAnnotations($definition, ServiceTag::class);
+            /** @var EventListener[] $listeners */
+            $listeners = $this->getDefinitionAnnotations($definition, EventListener::class);
+
+            foreach ($listeners as $listener) {
+                $definition->addTag($listener->getEventTag(), $listener->getAttributes());
+            }
 
             foreach ($tags as $tag) {
                 $definition->addTag($tag->getName(), $tag->getAttributes());
diff --git a/SimaServiceAnnotationsBundle.php b/SimaServiceAnnotationsBundle.php
@@ -4,12 +4,15 @@
 namespace SimonMarx\Symfony\Bundles\ServiceAnnotations;
 
 
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\DefinitionManipulationPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\DependencyInjectionPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\NoServicePass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ParentServicePass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceAliasPass;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceCallPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceTagArgumentPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceTagPass;
+use Symfony\Component\DependencyInjection\Compiler\PassConfig;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
@@ -18,13 +21,16 @@ class SimaServiceAnnotationsBundle extends Bundle
     public function build(ContainerBuilder $container)
     {
         parent::build($container);
-
         $container
-            ->addCompilerPass(new ServiceTagPass())
-            ->addCompilerPass(new ServiceAliasPass())
-            ->addCompilerPass(new DependencyInjectionPass())
-            ->addCompilerPass(new ServiceTagArgumentPass())
-            ->addCompilerPass(new ParentServicePass())
-            ->addCompilerPass(new NoServicePass());
+            ->addCompilerPass(new DefinitionManipulationPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+            ->addCompilerPass(new ServiceTagPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+            ->addCompilerPass(new ServiceAliasPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+            ->addCompilerPass(new DependencyInjectionPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+            ->addCompilerPass(new ServiceTagArgumentPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+            ->addCompilerPass(new ParentServicePass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+            ->addCompilerPass(new ServiceCallPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 1)
+
+            ->addCompilerPass(new NoServicePass(), PassConfig::TYPE_REMOVE);
+        ;
     }
 }
diff --git a/Utils/CompilerPassServiceAnnotationTrait.php b/Utils/CompilerPassServiceAnnotationTrait.php
@@ -4,6 +4,8 @@
 namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils;
 
 
+use App\DocReader\AnnotationHandler\RouteAnnotationHandler;
+use App\DocReader\AnnotationHandler\RouteHandler;
 use Doctrine\Common\Annotations\AnnotationReader;
 use ReflectionClass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\IgnoreParentServiceAnnotations;
@@ -41,7 +43,6 @@ private function definitionHasAnnotation(Definition $definition, string $annotat
             return false;
         }
 
-
         foreach ($this->getDefinitionAnnotations($definition) as $annotation) {
             if ($annotation instanceof $annotationClass) {
                 return true;
diff --git a/Utils/ReflectionCacheTrait.php b/Utils/ReflectionCacheTrait.php
@@ -42,6 +42,10 @@ public function getPropertyReflections(string $className, bool $recursive = fals
     {
         $classReflection = $this->getClassReflection($className, $recursive);
 
+        if (null === $classReflection) {
+            return [];
+        }
+
         $properties = $classReflection->getProperties();
 
         if (false !== $classReflection->getParentClass() && true === $recursive) {
@@ -76,18 +80,16 @@ public function getMethodReflection(string $className, string $methodName): ?Ref
         }
     }
 
-    public function getPropertyReflection(string $className, string $propertyName): ?ReflectionProperty
+    public function getPropertyReflection(string $className, string $propertyName, bool $recursive = false): ?ReflectionProperty
     {
-        $rc = $this->getClassReflection($className);
+        $properties = $this->getPropertyReflections($className, $propertyName, $recursive);
 
-        if (null === $rc) {
-            return null;
+        foreach ($properties as $property) {
+            if ($property->getName() === $propertyName) {
+                return $property;
+            }
         }
 
-        try {
-            return $rc->getProperty($propertyName);
-        } catch (ReflectionException $exception) {
-            return null;
-        }
+        return null;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,14 @@ class DependencyInjection`
`16`	`16`	`private ?string $serviceId = null;`
`17`	`17`	`private ?string $target = null;`
`18`	`18`	`private ?string $tagged = null;`
	`19`	`+ private ?string $parameter = null;`
`19`	`20`
`20`	`21`	`public function __construct(array $values = [])`
`21`	`22`	`{`
`22`	`23`	`$this->serviceId = $values['serviceId'] ?? $values['value'] ?? null;`
`23`	`24`	`$this->target = $values['target'] ?? null;`
`24`	`25`	`$this->tagged = $values['tagged'] ?? null;`
	`26`	`+ $this->parameter = $values['parameter'] ?? null;`
`25`	`27`	`}`
`26`	`28`
`27`	`29`	`public function setServiceId(string $serviceId): void`
`@@ -47,6 +49,11 @@ public function setTarget(string $target): void`
`47`	`49`	`$this->target = $target;`
`48`	`50`	`}`
`49`	`51`
	`52`	`+ public function getParameter(): ?string`
	`53`	`+ {`
	`54`	`+ return $this->parameter;`
	`55`	`+ }`
	`56`	`+`
`50`	`57`	`public function getTarget(): ?string`
`51`	`58`	`{`
`52`	`59`	`return $this->target;`
Original file line number	Diff line number	Diff line change
`@@ -13,13 +13,11 @@`
`13`	`13`	`class ServiceTag`
`14`	`14`	`{`
`15`	`15`	`private string $name;`
`16`		`- private ?int $priority = null;`
`17`	`16`	`private array $attributes = [];`
`18`	`17`
`19`	`18`	`public function __construct(array $values = [])`
`20`	`19`	`{`
`21`	`20`	`$this->name = $values['name'] ?? $values['value'];`
`22`		`- $this->priority = $values['priority'] ?? null;`
`23`	`21`
`24`	`22`	`if (\array_key_exists('value', $values)) {`
`25`	`23`	`unset($values['value']);`
`@@ -35,11 +33,6 @@ public function getName(): string`
`35`	`33`	`return $this->name;`
`36`	`34`	`}`
`37`	`35`
`38`		`- public function getPriority(): ?int`
`39`		`- {`
`40`		`- return $this->priority ?: $this->getAttributes()['priority'] ?? null;`
`41`		`- }`
`42`		`-`
`43`	`36`	`public function getAttributes(): array`
`44`	`37`	`{`
`45`	`38`	`return $this->attributes;`
Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,12 @@ class DependencyInjectionPass implements CompilerPassInterface`
`21`	`21`	`use CompilerPassServiceAnnotationTrait;`
`22`	`22`	`use ReflectionCacheTrait;`
`23`	`23`
	`24`	`+ private ContainerBuilder $container;`
	`25`	`+`
`24`	`26`	`public function process(ContainerBuilder $container)`
`25`	`27`	`{`
	`28`	`+ $this->container = $container;`
	`29`	`+`
`26`	`30`	`foreach ($container->getDefinitions() as $definition) {`
`27`	`31`	`if (false === $this->definitionHasValidClass($definition)) {`
`28`	`32`	`continue;`
`@@ -35,6 +39,11 @@ public function process(ContainerBuilder $container)`
`35`	`39`	`}`
`36`	`40`	`}`
`37`	`41`
	`42`	`+ private function findParameter(string $name)`
	`43`	`+ {`
	`44`	`+ return $this->container->getParameter($name);`
	`45`	`+ }`
	`46`	`+`
`38`	`47`	`private function handlePropertyAnnotations(ClassAnnotationScan $annotationScan, Definition $definition)`
`39`	`48`	`{`
`40`	`49`	`/**`
`@@ -55,15 +64,21 @@ private function handlePropertyAnnotations(ClassAnnotationScan $annotationScan,`
`55`	`64`	`$propertyAnnotation = $propertyAnnotations[0];`
`56`	`65`
`57`	`66`	`if (null === $propertyAnnotation->getServiceId() && null === $propertyAnnotation->getTagged()) {`
`58`		`- throw new InvalidServiceAnnotationException(\sprintf('Property %s::%s has @DependencyInjection without "serviceId" and "tagged" option. One of them must be defined'));`
	`67`	`+ throw new InvalidServiceAnnotationException(\sprintf('Property %s::%s has @DependencyInjection without "serviceId", "tagged" or "parameter" option. One of them must be defined', $property->getDeclaringClass()->getName(), $property->getName()));`
`59`	`68`	`}`
`60`	`69`
`61`	`70`
`62`	`71`	`if (null !== $propertyAnnotation->getServiceId()) {`
`63`	`72`	`$definition->setProperty($property->getName(), service($propertyAnnotation->getServiceId()));`
`64`		`- } elseif (null !== $propertyAnnotation->getTagged()) {`
	`73`	`+ }`
	`74`	`+`
	`75`	`+ if (null !== $propertyAnnotation->getTagged()) {`
`65`	`76`	`$definition->setProperty($property->getName(), tagged_iterator($propertyAnnotation->getTagged()));`
`66`	`77`	`}`
	`78`	`+`
	`79`	`+ if (null !== $propertyAnnotation->getParameter()) {`
	`80`	`+ $definition->setProperty($property->getName(), $this->findParameter($propertyAnnotation->getParameter()));`
	`81`	`+ }`
`67`	`82`	`}`
`68`	`83`	`}`
`69`	`84`
`@@ -96,9 +111,15 @@ private function handleMethodAnnotations(ClassAnnotationScan $annotationScan, De`
`96`	`111`	`if ($foundTargetAnnotation instanceof DependencyInjection) {`
`97`	`112`	`if (null !== $foundTargetAnnotation->getServiceId()) {`
`98`	`113`	`$definition->setArgument(\sprintf('$%s', $parameter->getName()), new Reference($foundTargetAnnotation->getServiceId()));`
`99`		`- } elseif (null !== $foundTargetAnnotation->getTagged()) {`
	`114`	`+ }`
	`115`	`+`
	`116`	`+ if (null !== $foundTargetAnnotation->getTagged()) {`
`100`	`117`	`$definition->setArgument(\sprintf('$%s', $parameter->getName()), tagged_iterator($foundTargetAnnotation->getTagged()));`
`101`	`118`	`}`
	`119`	`+`
	`120`	`+ if (null !== $foundTargetAnnotation->getParameter()) {`
	`121`	`+ $definition->setArgument(\sprintf('$%s', $parameter->getName()), $this->findParameter($foundTargetAnnotation->getParameter()));`
	`122`	`+ }`
`102`	`123`	`}`
`103`	`124`	`}`
`104`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,10 @@ public function getPropertyReflections(string $className, bool $recursive = fals`
`42`	`42`	`{`
`43`	`43`	`$classReflection = $this->getClassReflection($className, $recursive);`
`44`	`44`
	`45`	`+ if (null === $classReflection) {`
	`46`	`+ return [];`
	`47`	`+ }`
	`48`	`+`
`45`	`49`	`$properties = $classReflection->getProperties();`
`46`	`50`
`47`	`51`	`if (false !== $classReflection->getParentClass() && true === $recursive) {`
`@@ -76,18 +80,16 @@ public function getMethodReflection(string $className, string $methodName): ?Ref`
`76`	`80`	`}`
`77`	`81`	`}`
`78`	`82`
`79`		`- public function getPropertyReflection(string $className, string $propertyName): ?ReflectionProperty`
	`83`	`+ public function getPropertyReflection(string $className, string $propertyName, bool $recursive = false): ?ReflectionProperty`
`80`	`84`	`{`
`81`		`- $rc = $this->getClassReflection($className);`
	`85`	`+ $properties = $this->getPropertyReflections($className, $propertyName, $recursive);`
`82`	`86`
`83`		`- if (null === $rc) {`
`84`		`- return null;`
	`87`	`+ foreach ($properties as $property) {`
	`88`	`+ if ($property->getName() === $propertyName) {`
	`89`	`+ return $property;`
	`90`	`+ }`
`85`	`91`	`}`
`86`	`92`
`87`		`- try {`
`88`		`- return $rc->getProperty($propertyName);`
`89`		`- } catch (ReflectionException $exception) {`
`90`		`- return null;`
`91`		`- }`
	`93`	`+ return null;`
`92`	`94`	`}`
`93`	`95`	`}`