<form method="POST">
    <h3>Editing: ControllerResolver.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\HttpKernel\Controller;

use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\Request;

/**
 * This implementation uses the '_controller' request attribute to determine
 * the controller to execute.
 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 * @author Tobias Schultze &lt;http://tobion.de&gt;
 */
class ControllerResolver implements ControllerResolverInterface
{
    private $logger;

    public function __construct(?LoggerInterface $logger = null)
    {
        $this-&gt;logger = $logger;
    }

    /**
     * {@inheritdoc}
     */
    public function getController(Request $request)
    {
        if (!$controller = $request-&gt;attributes-&gt;get('_controller')) {
            if (null !== $this-&gt;logger) {
                $this-&gt;logger-&gt;warning('Unable to look for the controller as the &quot;_controller&quot; parameter is missing.');
            }

            return false;
        }

        if (\is_array($controller)) {
            if (isset($controller[0]) &amp;&amp; \is_string($controller[0]) &amp;&amp; isset($controller[1])) {
                try {
                    $controller[0] = $this-&gt;instantiateController($controller[0]);
                } catch (\Error|\LogicException $e) {
                    try {
                        // We cannot just check is_callable but have to use reflection because a non-static method
                        // can still be called statically in PHP but we don't want that. This is deprecated in PHP 7, so we
                        // could simplify this with PHP 8.
                        if ((new \ReflectionMethod($controller[0], $controller[1]))-&gt;isStatic()) {
                            return $controller;
                        }
                    } catch (\ReflectionException $reflectionException) {
                        throw $e;
                    }

                    throw $e;
                }
            }

            if (!\is_callable($controller)) {
                throw new \InvalidArgumentException(sprintf('The controller for URI &quot;%s&quot; is not callable: ', $request-&gt;getPathInfo()).$this-&gt;getControllerError($controller));
            }

            return $controller;
        }

        if (\is_object($controller)) {
            if (!\is_callable($controller)) {
                throw new \InvalidArgumentException(sprintf('The controller for URI &quot;%s&quot; is not callable: ', $request-&gt;getPathInfo()).$this-&gt;getControllerError($controller));
            }

            return $controller;
        }

        if (\function_exists($controller)) {
            return $controller;
        }

        try {
            $callable = $this-&gt;createController($controller);
        } catch (\InvalidArgumentException $e) {
            throw new \InvalidArgumentException(sprintf('The controller for URI &quot;%s&quot; is not callable: ', $request-&gt;getPathInfo()).$e-&gt;getMessage(), 0, $e);
        }

        if (!\is_callable($callable)) {
            throw new \InvalidArgumentException(sprintf('The controller for URI &quot;%s&quot; is not callable: ', $request-&gt;getPathInfo()).$this-&gt;getControllerError($callable));
        }

        return $callable;
    }

    /**
     * Returns a callable for the given controller.
     *
     * @return callable
     *
     * @throws \InvalidArgumentException When the controller cannot be created
     */
    protected function createController(string $controller)
    {
        if (!str_contains($controller, '::')) {
            $controller = $this-&gt;instantiateController($controller);

            if (!\is_callable($controller)) {
                throw new \InvalidArgumentException($this-&gt;getControllerError($controller));
            }

            return $controller;
        }

        [$class, $method] = explode('::', $controller, 2);

        try {
            $controller = [$this-&gt;instantiateController($class), $method];
        } catch (\Error|\LogicException $e) {
            try {
                if ((new \ReflectionMethod($class, $method))-&gt;isStatic()) {
                    return $class.'::'.$method;
                }
            } catch (\ReflectionException $reflectionException) {
                throw $e;
            }

            throw $e;
        }

        if (!\is_callable($controller)) {
            throw new \InvalidArgumentException($this-&gt;getControllerError($controller));
        }

        return $controller;
    }

    /**
     * Returns an instantiated controller.
     *
     * @return object
     */
    protected function instantiateController(string $class)
    {
        return new $class();
    }

    private function getControllerError($callable): string
    {
        if (\is_string($callable)) {
            if (str_contains($callable, '::')) {
                $callable = explode('::', $callable, 2);
            } else {
                return sprintf('Function &quot;%s&quot; does not exist.', $callable);
            }
        }

        if (\is_object($callable)) {
            $availableMethods = $this-&gt;getClassMethodsWithoutMagicMethods($callable);
            $alternativeMsg = $availableMethods ? sprintf(' or use one of the available methods: &quot;%s&quot;', implode('&quot;, &quot;', $availableMethods)) : '';

            return sprintf('Controller class &quot;%s&quot; cannot be called without a method name. You need to implement &quot;__invoke&quot;%s.', get_debug_type($callable), $alternativeMsg);
        }

        if (!\is_array($callable)) {
            return sprintf('Invalid type for controller given, expected string, array or object, got &quot;%s&quot;.', get_debug_type($callable));
        }

        if (!isset($callable[0]) || !isset($callable[1]) || 2 !== \count($callable)) {
            return 'Invalid array callable, expected [controller, method].';
        }

        [$controller, $method] = $callable;

        if (\is_string($controller) &amp;&amp; !class_exists($controller)) {
            return sprintf('Class &quot;%s&quot; does not exist.', $controller);
        }

        $className = \is_object($controller) ? get_debug_type($controller) : $controller;

        if (method_exists($controller, $method)) {
            return sprintf('Method &quot;%s&quot; on class &quot;%s&quot; should be public and non-abstract.', $method, $className);
        }

        $collection = $this-&gt;getClassMethodsWithoutMagicMethods($controller);

        $alternatives = [];

        foreach ($collection as $item) {
            $lev = levenshtein($method, $item);

            if ($lev &lt;= \strlen($method) / 3 || str_contains($item, $method)) {
                $alternatives[] = $item;
            }
        }

        asort($alternatives);

        $message = sprintf('Expected method &quot;%s&quot; on class &quot;%s&quot;', $method, $className);

        if (\count($alternatives) &gt; 0) {
            $message .= sprintf(', did you mean &quot;%s&quot;?', implode('&quot;, &quot;', $alternatives));
        } else {
            $message .= sprintf('. Available methods: &quot;%s&quot;.', implode('&quot;, &quot;', $collection));
        }

        return $message;
    }

    private function getClassMethodsWithoutMagicMethods($classOrObject): array
    {
        $methods = get_class_methods($classOrObject);

        return array_filter($methods, function (string $method) {
            return 0 !== strncmp($method, '__', 2);
        });
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>