PHP-DI · mnapoli · Aug 12, 2015 · Aug 12, 2015 · Aug 12, 2015 · Aug 12, 2015
diff --git a/src/DI/Definition/AbstractFunctionCallDefinition.php b/src/DI/Definition/AbstractFunctionCallDefinition.php
diff --git a/src/DI/Definition/Dumper/ObjectDefinitionDumper.php b/src/DI/Definition/Dumper/ObjectDefinitionDumper.php
@@ -120,9 +120,11 @@ private function dumpMethodParameters($className, MethodInjection $methodInjecti
 
         $args = [];
 
+        $definitionParameters = $methodInjection->getParameters();
+
         foreach ($methodReflection->getParameters() as $index => $parameter) {
-            if ($methodInjection->hasParameter($index)) {
-                $value = $methodInjection->getParameter($index);
+            if (array_key_exists($index, $definitionParameters)) {
+                $value = $definitionParameters[$index];
 
                 if ($value instanceof EntryReference) {
                     $args[] = sprintf('$%s = get(%s)', $parameter->getName(), $value->getName());

diff --git a/src/DI/Definition/ObjectDefinition/MethodInjection.php b/src/DI/Definition/ObjectDefinition/MethodInjection.php
@@ -9,20 +9,26 @@
 
 namespace DI\Definition\ObjectDefinition;
 
-use DI\Definition\AbstractFunctionCallDefinition;
+use DI\Definition\Definition;
+use DI\Scope;
 
 /**
  * Describe an injection in an object method.
  *
  * @author Matthieu Napoli <[email protected]>
  */
-class MethodInjection extends AbstractFunctionCallDefinition
+class MethodInjection implements Definition
 {
     /**
      * @var string
      */
     private $methodName;
 
+    /**
+     * @var array
+     */
+    private $parameters = [];
+
     /**
      * @param string $methodName
      * @param array  $parameters
@@ -46,9 +52,43 @@ public function getMethodName()
         return $this->methodName;
     }
 
+    /**
+     * @return array
+     */
+    public function getParameters()
+    {
+        return $this->parameters;
+    }
+
+    /**
+     * Replace the parameters of the definition by a new array of parameters.
+     *
+     * @param array $parameters
+     */
+    public function replaceParameters(array $parameters)
+    {
+        $this->parameters = $parameters;
+    }
+
     public function merge(MethodInjection $definition)
     {
         // In case of conflicts, the current definition prevails.
         $this->parameters = $this->parameters + $definition->parameters;
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getScope()
+    {
+        return Scope::PROTOTYPE;
+    }
 }
diff --git a/src/DI/Definition/Resolver/ParameterResolver.php b/src/DI/Definition/Resolver/ParameterResolver.php
@@ -9,10 +9,10 @@
 
 namespace DI\Definition\Resolver;
 
-use DI\Definition\AbstractFunctionCallDefinition;
 use DI\Definition\ObjectDefinition;
 use DI\Definition\Exception\DefinitionException;
 use DI\Definition\Helper\DefinitionHelper;
+use DI\Definition\ObjectDefinition\MethodInjection;
 
 /**
  * Resolves parameters for a function call.
@@ -36,15 +36,15 @@ public function __construct(DefinitionResolver $definitionResolver)
     }
 
     /**
-     * @param AbstractFunctionCallDefinition $definition
-     * @param \ReflectionFunctionAbstract    $functionReflection
-     * @param array                          $parameters
+     * @param MethodInjection             $definition
+     * @param \ReflectionFunctionAbstract $functionReflection
+     * @param array                       $parameters
      *
      * @throws DefinitionException A parameter has no value defined or guessable.
      * @return array Parameters to use to call the function.
      */
     public function resolveParameters(
-        AbstractFunctionCallDefinition $definition = null,
+        MethodInjection $definition = null,
         \ReflectionFunctionAbstract $functionReflection = null,
         array $parameters = []
     ) {
@@ -54,13 +54,15 @@ public function resolveParameters(
             return $args;
         }
 
+        $definitionParameters = $definition ? $definition->getParameters() : array();
+
         foreach ($functionReflection->getParameters() as $index => $parameter) {
             if (array_key_exists($parameter->getName(), $parameters)) {
                 // Look in the $parameters array
                 $value = $parameters[$parameter->getName()];
-            } elseif ($definition && $definition->hasParameter($index)) {
+            } elseif (array_key_exists($index, $definitionParameters)) {
                 // Look in the definition
-                $value = $definition->getParameter($index);
+                $value = $definitionParameters[$index];
             } else {
                 // If the parameter is optional and wasn't specified, we take its default value
                 if ($parameter->isOptional()) {
@@ -79,7 +81,7 @@ public function resolveParameters(
                 $nestedDefinition = $value->getDefinition('');
 
                 // If the container cannot produce the entry, we can use the default parameter value
-                if (!$this->definitionResolver->isResolvable($nestedDefinition) && $parameter->isOptional()) {
+                if ($parameter->isOptional() && !$this->definitionResolver->isResolvable($nestedDefinition)) {
                     $value = $this->getParameterDefaultValue($parameter, $functionReflection);
                 } else {
                     $value = $this->definitionResolver->resolve($nestedDefinition);

diff --git a/src/DI/Definition/Resolver/ResolverDispatcher.php b/src/DI/Definition/Resolver/ResolverDispatcher.php
@@ -85,57 +85,54 @@ public function isResolvable(Definition $definition, array $parameters = [])
      */
     private function getDefinitionResolver(Definition $definition)
     {
-        $definitionType = get_class($definition);
-
-        switch ($definitionType) {
-            case 'DI\Definition\ValueDefinition':
+        switch (true) {
+            case ($definition instanceof \DI\Definition\ObjectDefinition):
+                if (! $this->objectResolver) {
+                    $this->objectResolver = new ObjectCreator($this, $this->proxyFactory);
+                }
+                return $this->objectResolver;
+            case ($definition instanceof \DI\Definition\ValueDefinition):
                 if (! $this->valueResolver) {
                     $this->valueResolver = new ValueResolver();
                 }
                 return $this->valueResolver;
-            case 'DI\Definition\ArrayDefinition':
-            case 'DI\Definition\ArrayDefinitionExtension':
-                if (! $this->arrayResolver) {
-                    $this->arrayResolver = new ArrayResolver($this);
-                }
-                return $this->arrayResolver;
-            case 'DI\Definition\FactoryDefinition':
-                if (! $this->factoryResolver) {
-                    $this->factoryResolver = new FactoryResolver($this->container);
+            case ($definition instanceof \DI\Definition\AliasDefinition):
+                if (! $this->aliasResolver) {
+                    $this->aliasResolver = new AliasResolver($this->container);
                 }
-                return $this->factoryResolver;
-            case 'DI\Definition\DecoratorDefinition':
+                return $this->aliasResolver;
+            case ($definition instanceof \DI\Definition\DecoratorDefinition):
                 if (! $this->decoratorResolver) {
                     $this->decoratorResolver = new DecoratorResolver($this->container, $this);
                 }
                 return $this->decoratorResolver;
-            case 'DI\Definition\AliasDefinition':
-                if (! $this->aliasResolver) {
-                    $this->aliasResolver = new AliasResolver($this->container);
-                }
-                return $this->aliasResolver;
-            case 'DI\Definition\ObjectDefinition':
-                if (! $this->objectResolver) {
-                    $this->objectResolver = new ObjectCreator($this, $this->proxyFactory);
+            case ($definition instanceof \DI\Definition\FactoryDefinition):
+                if (! $this->factoryResolver) {
+                    $this->factoryResolver = new FactoryResolver($this->container);
                 }
-                return $this->objectResolver;
-            case 'DI\Definition\InstanceDefinition':
-                if (! $this->instanceResolver) {
-                    $this->instanceResolver = new InstanceInjector($this, $this->proxyFactory);
+                return $this->factoryResolver;
+            case ($definition instanceof \DI\Definition\ArrayDefinition):
+                if (! $this->arrayResolver) {
+                    $this->arrayResolver = new ArrayResolver($this);
                 }
-                return $this->instanceResolver;
-            case 'DI\Definition\EnvironmentVariableDefinition':
+                return $this->arrayResolver;
+            case ($definition instanceof \DI\Definition\EnvironmentVariableDefinition):
                 if (! $this->envVariableResolver) {
                     $this->envVariableResolver = new EnvironmentVariableResolver($this);
                 }
                 return $this->envVariableResolver;
-            case 'DI\Definition\StringDefinition':
+            case ($definition instanceof \DI\Definition\StringDefinition):
                 if (! $this->stringResolver) {
                     $this->stringResolver = new StringResolver($this->container);
                 }
                 return $this->stringResolver;
+            case ($definition instanceof \DI\Definition\InstanceDefinition):
+                if (! $this->instanceResolver) {
+                    $this->instanceResolver = new InstanceInjector($this, $this->proxyFactory);
+                }
+                return $this->instanceResolver;
             default:
-                throw new \RuntimeException("No definition resolver was configured for definition of type $definitionType");
+                throw new \RuntimeException('No definition resolver was configured for definition of type ' . get_class($definition));
         }
     }
 }