AnnotationBasedAutowiring with additional options for performance tweaks

- adds possibility to disable features which are not used
- useAnnotations(boolean) toggle on autowire() helper to enable/disable reading annotations on specific definitions

Author: falkenhawk

src/ContainerBuilder.php

@@ -52,6 +52,10 @@ class ContainerBuilder
 
     private bool $useAutowiring = true;
 
+    private int $annotationsFlags = 0;
+
+    private bool $ignorePhpDocErrors = false;
+
     private bool $useAttributes = false;
 
     /**
@@ -146,7 +150,7 @@ public function build()
                 $this->compileToDirectory,
                 $containerClass,
                 $this->containerParentClass,
-                $this->useAutowiring
+                $this->useAutowiring || $this->useAttributes
             );
             // Only load the file if it hasn't been already loaded
             // (the container can be created multiple times in the same process)
@@ -216,11 +220,12 @@ public function useAutowiring(bool $bool) : self
      *
      * @return $this
      */
-    public function useAttributes(bool $bool) : self
+    public function useAttributes(bool $bool, int $flags = 0) : self
     {
         $this->ensureNotLocked();
 
         $this->useAttributes = $bool;
+        $this->annotationsFlags = $flags;
 
         return $this;
     }

src/Definition/AutowireDefinition.php

@@ -9,4 +9,26 @@
  */
 class AutowireDefinition extends ObjectDefinition
 {
+    /**
+     * @var bool|null
+     */
+    protected $useAnnotations;
+
+    /**
+     * Enable/disable reading annotations for this definition, regardless of a container configuration.
+     * @param bool $flag
+     */
+    public function useAnnotations(bool $flag = true)
+    {
+        $this->useAnnotations = $flag;
+    }
+
+    /**
+     * Returns boolean if the useAnnotation flag was explicitly set, otherwise null.
+     * @return bool|null
+     */
+    public function isUsingAnnotations()
+    {
+        return $this->useAnnotations;
+    }
 }

src/Definition/Helper/AutowireDefinitionHelper.php

@@ -5,6 +5,7 @@
 namespace DI\Definition\Helper;
 
 use DI\Definition\AutowireDefinition;
+use DI\Definition\Definition;
 
 /**
  * Helps defining how to create an instance of a class using autowiring.
@@ -15,6 +16,8 @@ class AutowireDefinitionHelper extends CreateDefinitionHelper
 {
     public const DEFINITION_CLASS = AutowireDefinition::class;
 
+    protected $useAnnotations;
+
     /**
      * Defines a value for a specific argument of the constructor.
      *
@@ -69,4 +72,31 @@ public function methodParameter(string $method, string|int $parameter, mixed $va
 
         return $this;
     }
+
+    /**
+     * Define if entry should use annotation reader for reading dependencies.
+     * This is turned off by default if autowire() helper is used, and turned on if entry is not defined explicitly in the di config.
+     * @param bool $useAnnotations
+     * @return $this
+     */
+    public function useAnnotations(bool $useAnnotations = true)
+    {
+        $this->useAnnotations = $useAnnotations;
+
+        return $this;
+    }
+
+    /**
+     * @return AutowireDefinition
+     */
+    public function getDefinition(string $entryName) : Definition
+    {
+        /** @var AutowireDefinition $definition */
+        $definition = parent::getDefinition($entryName);
+        if ($this->useAnnotations !== null) {
+            $definition->useAnnotations($this->useAnnotations);
+        }
+
+        return $definition;
+    }
 }

src/Definition/Source/AttributeBasedAutowiring.php

@@ -6,6 +6,7 @@
 
 use DI\Attribute\Inject;
 use DI\Attribute\Injectable;
+use DI\Definition\AutowireDefinition;
 use DI\Definition\Exception\InvalidAttribute;
 use DI\Definition\ObjectDefinition;
 use DI\Definition\ObjectDefinition\MethodInjection;
@@ -28,9 +29,25 @@
  */
 class AttributeBasedAutowiring implements DefinitionSource, Autowiring
 {
-    /**
-     * @throws InvalidAttribute
-     */
+    // Annotations configuration flags:
+    // enable on implicit definitions
+    const IMPLICIT = 1;
+    // enable on all autowire definitions (which are written in DI config) by default
+    const EXPLICIT = 2;
+    // read @Injectable annotations for classes
+    const INJECTABLE = 4;
+    // read @Inject annotations for properties
+    const PROPERTIES = 8;
+    // read @Inject annotations for methods' parameters
+    const METHODS = 16;
+    // all options enabled
+    const ALL = 31;
+
+    public function __construct(private int $flags = 0)
+    {
+        $this->flags = $flags > 0 ? $flags : self::ALL; // all flags turned on by default
+    }
+
     public function autowire(string $name, ObjectDefinition $definition = null) : ObjectDefinition|null
     {
         $className = $definition ? $definition->getClassName() : $name;
@@ -40,16 +57,36 @@ public function autowire(string $name, ObjectDefinition $definition = null) : Ob
         }
 
         $definition = $definition ?: new ObjectDefinition($name);
+        $useAnnotations = $definition instanceof AutowireDefinition
+            ? ($definition->isUsingAnnotations() ?? ($this->flags & self::EXPLICIT))
+            : ($this->flags & self::IMPLICIT);
 
-        $class = new ReflectionClass($className);
+        $class = null;
+        if ($useAnnotations && $this->flags >= self::INJECTABLE) {
+            $class = new ReflectionClass($className);
 
         $this->readInjectableAttribute($class, $definition);
+            if ($this->flags & self::INJECTABLE) {
+                $this->readInjectableAnnotation($class, $definition);
+            }
 
-        // Browse the class properties looking for annotated properties
-        $this->readProperties($class, $definition);
+            // Browse the class properties looking for annotated properties
+            if ($this->flags & self::PROPERTIES) {
+                $this->readProperties($class, $definition);
+            }
 
-        // Browse the object's methods looking for annotated methods
-        $this->readMethods($class, $definition);
+            // Browse the object's methods looking for annotated methods
+            if ($this->flags & self::METHODS) {
+                $this->readMethods($class, $definition);
+            }
+        }
+
+        // constructor parameters should always be read, even if annotations are disabled (completely or i.a. for methods)
+        // so that it behaves at least as ReflectionBasedAutowiring
+        if (!$useAnnotations || !($this->flags & self::METHODS)) {
+            $class = $class ?? new ReflectionClass($className);
+            $this->readConstructor($class, $definition);
+        }
 
         return $definition;
     }
@@ -260,4 +297,26 @@ private function readInjectableAttribute(ReflectionClass $class, ObjectDefinitio
             $definition->setLazy($attribute->isLazy());
         }
     }
+
+    /**
+     * Browse the object's constructor parameters and inject dependencies.
+     */
+    private function readConstructor(ReflectionClass $class, ObjectDefinition $definition)
+    {
+        if (!($constructor = $class->getConstructor()) || !$constructor->isPublic()) {
+            return;
+        }
+
+        $parameters = [];
+        foreach ($constructor->getParameters() as $index => $parameter) {
+            $entryName = $this->getMethodParameter($index, $parameter, []);
+
+            if ($entryName !== null) {
+                $parameters[$index] = new Reference($entryName);
+            }
+        }
+
+        $constructorInjection = MethodInjection::constructor($parameters);
+        $definition->completeConstructorInjection($constructorInjection);
+    }
 }