Optimizations

src/DI/Definition/ObjectDefinition.php

@@ -11,8 +11,8 @@
 
 use DI\Definition\ObjectDefinition\MethodInjection;
 use DI\Definition\ObjectDefinition\PropertyInjection;
-use DI\Definition\Exception\DefinitionException;
 use DI\Scope;
+use ReflectionClass;
 
 /**
  * Defines how an object can be instantiated.
@@ -61,14 +61,28 @@ class ObjectDefinition implements Definition, CacheableDefinition, HasSubDefinit
      */
     private $lazy;
 
+    /**
+     * Store if the class exists. Storing it (in cache) avoids recomputing this.
+     *
+     * @var bool
+     */
+    private $classExists;
+
+    /**
+     * Store if the class is instantiable. Storing it (in cache) avoids recomputing this.
+     *
+     * @var bool
+     */
+    private $isInstantiable;
+
     /**
      * @param string $name Class name
      * @param string $className
      */
     public function __construct($name, $className = null)
     {
         $this->name = (string) $name;
-        $this->className = $className;
+        $this->setClassName($className);
     }
 
     /**
@@ -80,11 +94,13 @@ public function getName()
     }
 
     /**
-     * @param string $className
+     * @param string|null $className
      */
     public function setClassName($className)
     {
         $this->className = $className;
+
+        $this->updateCache();
     }
 
     /**
@@ -201,6 +217,22 @@ public function isLazy()
         }
     }
 
+    /**
+     * @return bool
+     */
+    public function classExists()
+    {
+        return $this->classExists;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isInstantiable()
+    {
+        return $this->isInstantiable;
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -220,7 +252,7 @@ public function setSubDefinition(Definition $definition)
 
         // The current prevails
         if ($this->className === null) {
-            $this->className = $definition->className;
+            $this->setClassName($definition->className);
         }
         if ($this->scope === null) {
             $this->scope = $definition->scope;
@@ -287,4 +319,19 @@ private function mergeMethodCalls(array $calls, $methodName)
             }
         }
     }
+
+    private function updateCache()
+    {
+        $className = $this->getClassName();
+
+        $this->classExists = class_exists($className) || interface_exists($className);
+
+        if (! $this->classExists) {
+            $this->isInstantiable = false;
+            return;
+        }
+
+        $class = new ReflectionClass($className);
+        $this->isInstantiable = $class->isInstantiable();
+    }
 }

src/DI/Definition/Resolver/ArrayResolver.php

@@ -61,8 +61,6 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsArrayDefinition($definition);
-
         return true;
     }
 

src/DI/Definition/Resolver/DecoratorResolver.php

@@ -90,8 +90,6 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsDecoratorDefinition($definition);
-
         return true;
     }
 

src/DI/Definition/Resolver/EnvironmentVariableResolver.php

@@ -78,10 +78,7 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsEnvironmentVariableDefinition($definition);
-
-        return $definition->isOptional()
-            || false !== call_user_func($this->variableReader, $definition->getVariableName());
+        return true;
     }
 
     private function assertIsEnvironmentVariableDefinition(Definition $definition)

src/DI/Definition/Resolver/FactoryResolver.php

@@ -68,8 +68,6 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsFactoryDefinition($definition);
-
         return true;
     }
 

src/DI/Definition/Resolver/InstanceInjector.php

@@ -50,8 +50,6 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsInstanceDefinition($definition);
-
         return true;
     }
 

src/DI/Definition/Resolver/ObjectCreator.php

@@ -91,13 +91,7 @@ public function isResolvable(Definition $definition, array $parameters = [])
     {
         $this->assertIsObjectDefinition($definition);
 
-        if (! class_exists($definition->getClassName())) {
-            return false;
-        }
-
-        $classReflection = new ReflectionClass($definition->getClassName());
-
-        return $classReflection->isInstantiable();
+        return $definition->isInstantiable();
     }
 
     /**
@@ -127,7 +121,7 @@ function (& $wrappedObject, $proxy, $method, $params, & $initializer) use ($defi
      * Creates an instance of the class and injects dependencies..
      *
      * @param ObjectDefinition $definition
-     * @param array           $parameters      Optional parameters to use to create the instance.
+     * @param array            $parameters      Optional parameters to use to create the instance.
      *
      * @throws DefinitionException
      * @throws DependencyException
@@ -140,7 +134,7 @@ private function createInstance(ObjectDefinition $definition, array $parameters)
         $classname = $definition->getClassName();
         $classReflection = new ReflectionClass($classname);
 
-        $this->assertClassIsInstantiable($definition, $classReflection);
+        $this->assertClassIsInstantiable($definition);
 
         $constructorInjection = $definition->getConstructorInjection();
 
@@ -172,7 +166,7 @@ private function createInstance(ObjectDefinition $definition, array $parameters)
             ));
         }
 
-        if(is_object($object) === false) {
+        if (! $object) {
             throw new DependencyException(sprintf(
                 "Entry %s cannot be resolved: %s could not be constructed",
                 $definition->getName(),
@@ -254,7 +248,7 @@ private function assertIsObjectDefinition(Definition $definition)
 
     private function assertClassExists(ObjectDefinition $definition)
     {
-        if (!class_exists($definition->getClassName()) && !interface_exists($definition->getClassName())) {
+        if (! $definition->classExists()) {
             throw DefinitionException::create($definition,
             sprintf(
                 "Entry %s cannot be resolved: class %s doesn't exist",
@@ -264,9 +258,9 @@ private function assertClassExists(ObjectDefinition $definition)
         }
     }
 
-    private function assertClassIsInstantiable(ObjectDefinition $definition, ReflectionClass $classReflection)
+    private function assertClassIsInstantiable(ObjectDefinition $definition)
     {
-        if (!$classReflection->isInstantiable()) {
+        if (! $definition->isInstantiable()) {
             throw DefinitionException::create($definition,
             sprintf(
                 "Entry %s cannot be resolved: class %s is not instantiable",

src/DI/Definition/Resolver/StringResolver.php

@@ -78,8 +78,6 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsStringDefinition($definition);
-
         return true;
     }
 

src/DI/Definition/Resolver/ValueResolver.php

@@ -41,8 +41,6 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
-        $this->assertIsValueDefinition($definition);
-
         return true;
     }
 

tests/UnitTest/Definition/Resolver/EnvironmentVariableResolverTest.php

@@ -115,9 +115,10 @@ public function should_be_able_to_resolve_defined_env_variables()
     /**
      * @test
      */
-    public function should_not_be_able_to_resolve_undefined_env_variables()
+    public function should_be_able_to_resolve_undefined_env_variables()
     {
-        $this->assertFalse(
+        // See this thread https://github.com/container-interop/container-interop/issues/37
+        $this->assertTrue(
             $this->resolver->isResolvable($this->undefinedDefinition)
         );
     }