[5.4] Revert breaking changes in ControllerDispatcher::resolveMethodDependencies

src/Illuminate/Routing/RouteDependencyResolverTrait.php

@@ -37,28 +37,19 @@ protected function resolveClassMethodDependencies(array $parameters, $instance,
      */
     public function resolveMethodDependencies(array $parameters, ReflectionFunctionAbstract $reflector)
     {
-        $results = [];
-
-        $instanceCount = 0;
-
-        $values = array_values($parameters);
-
         foreach ($reflector->getParameters() as $key => $parameter) {
             $instance = $this->transformDependency(
                 $parameter, $parameters
             );
 
             if (! is_null($instance)) {
-                $instanceCount++;
-
-                $results[$parameter->getName()] = $instance;
-            } else {
-                $results[$parameter->getName()] = isset($values[$key - $instanceCount])
-                    ? $values[$key - $instanceCount] : $parameter->getDefaultValue();
+                array_splice(
+                    $parameters, $key, 0, [$instance]
+                );
             }
         }
 
-        return $results;
+        return $parameters;
     }
 
     /**

tests/Routing/ControllerDispatcherTest.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Illuminate\Tests\Routing;
+
+use ReflectionMethod;
+use PHPUnit\Framework\TestCase;
+use Illuminate\Container\Container;
+use Illuminate\Routing\ControllerDispatcher;
+
+class ControllerDispatcherTest extends TestCase
+{
+    /**
+     * @var \Illuminate\Routing\ControllerDispatcher
+     */
+    protected $controllerDispatcher;
+
+    public function setUp()
+    {
+        parent::setUp();
+
+        $container = new Container();
+        $this->controllerDispatcher = new ControllerDispatcher($container);
+    }
+
+    public function targetResolveMethodDependenciesKeepKeys($first)
+    {
+    }
+
+    public function testResolveMethodDependenciesKeepKeys()
+    {
+        $parameters = [
+            'first' => 'first-value',
+        ];
+        $target = new ReflectionMethod(self::class, 'targetResolveMethodDependenciesKeepKeys');
+
+        $actual = $this->controllerDispatcher->resolveMethodDependencies($parameters, $target);
+
+        $expected = [
+            'first' => 'first-value',
+        ];
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function targetResolveMethodDependenciesKeepsOrderOfKeysAndValues($first, $second)
+    {
+    }
+
+    public function testResolveMethodDependenciesKeepsOrderOfKeysAndValues()
+    {
+        $parameters = [
+            'second' => 'second-value',
+            'first' => 'first-value',
+        ];
+        $target = new ReflectionMethod(self::class, 'targetResolveMethodDependenciesKeepsOrderOfKeysAndValues');
+
+        $actual = $this->controllerDispatcher->resolveMethodDependencies($parameters, $target);
+
+        $expected = [
+            'second' => 'second-value',
+            'first' => 'first-value',
+        ];
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function targetResolveMethodDependenciesKeepsUnknownKeys($first)
+    {
+    }
+
+    public function testResolveMethodDependenciesKeepsUnknownKeys()
+    {
+        $parameters = [
+            'first' => 'first-value',
+            'unknown' => 'unknown',
+        ];
+        $target = new ReflectionMethod(self::class, 'targetResolveMethodDependenciesKeepsUnknownKeys');
+
+        $actual = $this->controllerDispatcher->resolveMethodDependencies($parameters, $target);
+
+        $expected = [
+            'first' => 'first-value',
+            'unknown' => 'unknown',
+        ];
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function targetResolveMethodDependenciesDoesNotCrashOnMissingKeys($first)
+    {
+    }
+
+    public function testResolveMethodDependenciesDoesNotCrashOnMissingKeys()
+    {
+        $parameters = [];
+        $target = new ReflectionMethod(self::class, 'targetResolveMethodDependenciesDoesNotCrashOnMissingKeys');
+
+        $actual = $this->controllerDispatcher->resolveMethodDependencies($parameters, $target);
+
+        $expected = [];
+        $this->assertEquals($expected, $actual);
+    }
+}

tests/Routing/RoutingRouteTest.php

@@ -314,15 +314,18 @@ public function testClassesAndVariablesCanBeInjectedIntoRoutes()
         unset($_SERVER['__test.route_inject']);
         $router = $this->getRouter();
         $router->get('foo/{var}/{bar?}/{baz?}', function (stdClass $foo, $var, $bar = 'test', stdClass $baz = null) {
-            $_SERVER['__test.route_inject'] = func_get_args();
+            // We build the array manually to ensure that we get the actual values in the method,
+            // and not the values that were originally sent to us; func_get_args() will only return
+            // the original values sent to us, not what the method received, including default values.
+            $_SERVER['__test.route_inject'] = [$foo, $var, $bar, $baz];
 
             return 'hello';
         });
         $this->assertEquals('hello', $router->dispatch(Request::create('foo/bar', 'GET'))->getContent());
         $this->assertInstanceOf('stdClass', $_SERVER['__test.route_inject'][0]);
         $this->assertEquals('bar', $_SERVER['__test.route_inject'][1]);
         $this->assertEquals('test', $_SERVER['__test.route_inject'][2]);
-        $this->assertInstanceOf('stdClass', $_SERVER['__test.route_inject'][3]);
+        $this->assertNull($_SERVER['__test.route_inject'][3]);
         $this->assertArrayHasKey(3, $_SERVER['__test.route_inject']);
         unset($_SERVER['__test.route_inject']);
     }