Merge 3adc708 into b84e946

src/DI/Cache/ArrayCache.php

@@ -30,7 +30,12 @@ class ArrayCache implements Cache, FlushableCache, ClearableCache
 
     public function fetch($id)
     {
-        return $this->contains($id) ? $this->data[$id] : false;
+        // isset() is required for performance optimizations, to avoid unnecessary function calls to array_key_exists.
+        if (isset($this->data[$id]) || array_key_exists($id, $this->data)) {
+            return $this->data[$id];
+        }
+
+        return false;
     }
 
     public function contains($id)

src/DI/Container.php

@@ -107,15 +107,8 @@ public function __construct(
      */
     public function get($name)
     {
-        if (! is_string($name)) {
-            throw new InvalidArgumentException(sprintf(
-                'The name parameter must be of type string, %s given',
-                is_object($name) ? get_class($name) : gettype($name)
-            ));
-        }
-
         // Try to find the entry in the singleton map
-        if (array_key_exists($name, $this->singletonEntries)) {
+        if (isset($this->singletonEntries[$name]) || array_key_exists($name, $this->singletonEntries)) {
             return $this->singletonEntries[$name];
         }
 

src/DI/Definition/Resolver/ObjectCreator.php

@@ -118,13 +118,25 @@ function (& $wrappedObject, $proxy, $method, $params, & $initializer) use ($defi
      */
     private function createInstance(ObjectDefinition $definition, array $parameters)
     {
-        $this->assertClassExists($definition);
+        // Check that the class is instantiable
+        if (! $definition->isInstantiable()) {
+            // Check that the class exists
+            if (! $definition->classExists()) {
+                throw DefinitionException::create($definition, sprintf(
+                    'Entry "%s" cannot be resolved: the class doesn\'t exist',
+                    $definition->getName()
+                ));
+            }
+
+            throw DefinitionException::create($definition, sprintf(
+                'Entry "%s" cannot be resolved: the class is not instantiable',
+                $definition->getName()
+            ));
+        }
 
         $classname = $definition->getClassName();
         $classReflection = new ReflectionClass($classname);
 
-        $this->assertClassIsInstantiable($definition);
-
         $constructorInjection = $definition->getConstructorInjection();
 
         try {
@@ -134,10 +146,26 @@ private function createInstance(ObjectDefinition $definition, array $parameters)
                 $parameters
             );
 
-            if (count($args) > 0) {
-                $object = $classReflection->newInstanceArgs($args);
-            } else {
-                $object = new $classname;
+            // Optimization trick
+            switch (count($args)) {
+                case 0:
+                    $object = new $classname;
+                    break;
+                case 1:
+                    $object = new $classname($args[0]);
+                    break;
+                case 2:
+                    $object = new $classname($args[0], $args[1]);
+                    break;
+                case 3:
+                    $object = new $classname($args[0], $args[1], $args[2]);
+                    break;
+                case 4:
+                    $object = new $classname($args[0], $args[1], $args[2], $args[3]);
+                    break;
+                default:
+                    $object = $classReflection->newInstanceArgs($args);
+                    break;
             }
 
             $this->injectMethodsAndProperties($object, $definition);
@@ -224,24 +252,4 @@ private function injectProperty($object, PropertyInjection $propertyInjection)
         }
         $property->setValue($object, $value);
     }
-
-    private function assertClassExists(ObjectDefinition $definition)
-    {
-        if (! $definition->classExists()) {
-            throw DefinitionException::create($definition, sprintf(
-                'Entry "%s" cannot be resolved: the class doesn\'t exist',
-                $definition->getName()
-            ));
-        }
-    }
-
-    private function assertClassIsInstantiable(ObjectDefinition $definition)
-    {
-        if (! $definition->isInstantiable()) {
-            throw DefinitionException::create($definition, sprintf(
-                'Entry "%s" cannot be resolved: the class is not instantiable',
-                $definition->getName()
-            ));
-        }
-    }
 }

src/DI/Definition/Resolver/ResolverDispatcher.php

@@ -53,6 +53,11 @@ public function __construct(ContainerInterface $container, ProxyFactory $proxyFa
      */
     public function resolve(Definition $definition, array $parameters = [])
     {
+        // Special case, tested early for speed
+        if ($definition instanceof \DI\Definition\SelfResolvingDefinition) {
+            return $definition->resolve($this->container);
+        }
+
         $definitionResolver = $this->getDefinitionResolver($definition);
 
         return $definitionResolver->resolve($definition, $parameters);
@@ -68,6 +73,11 @@ public function resolve(Definition $definition, array $parameters = [])
      */
     public function isResolvable(Definition $definition, array $parameters = [])
     {
+        // Special case, tested early for speed
+        if ($definition instanceof \DI\Definition\SelfResolvingDefinition) {
+            return $definition->isResolvable($this->container);
+        }
+
         $definitionResolver = $this->getDefinitionResolver($definition);
 
         return $definitionResolver->isResolvable($definition, $parameters);
@@ -84,12 +94,6 @@ public function isResolvable(Definition $definition, array $parameters = [])
     private function getDefinitionResolver(Definition $definition)
     {
         switch (true) {
-            case $definition instanceof \DI\Definition\SelfResolvingDefinition:
-                if (! $this->selfResolvingResolver) {
-                    $this->selfResolvingResolver = new SelfResolver($this->container);
-                }
-
-                return $this->selfResolvingResolver;
             case $definition instanceof \DI\Definition\ObjectDefinition:
                 if (! $this->objectResolver) {
                     $this->objectResolver = new ObjectCreator($this, $this->proxyFactory);

tests/UnitTest/Definition/Resolver/ResolverDispatcherTest.php

@@ -58,4 +58,15 @@ public function should_throw_if_non_handled_definition()
     {
         $this->resolver->resolve($this->easyMock(Definition::class));
     }
+
+    /**
+     * @test
+     */
+    public function should_resolve_definitions()
+    {
+        $definition = new ValueDefinition('foo', 'bar');
+
+        $this->assertTrue($this->resolver->isResolvable($definition));
+        $this->assertEquals('bar', $this->resolver->resolve($definition));
+    }
 }