<form method="POST">
    <h3>Editing: AnnotationClassLoader.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\Routing\Loader;

use Doctrine\Common\Annotations\Reader;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\Config\Loader\LoaderResolverInterface;
use Symfony\Component\Config\Resource\FileResource;
use Symfony\Component\Routing\Annotation\Route as RouteAnnotation;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;

/**
 * AnnotationClassLoader loads routing information from a PHP class and its methods.
 *
 * You need to define an implementation for the configureRoute() method. Most of the
 * time, this method should define some PHP callable to be called for the route
 * (a controller in MVC speak).
 *
 * The @Route annotation can be set on the class (for global parameters),
 * and on each method.
 *
 * The @Route annotation main value is the route path. The annotation also
 * recognizes several parameters: requirements, options, defaults, schemes,
 * methods, host, and name. The name parameter is mandatory.
 * Here is an example of how you should be able to use it:
 *     /**
 *      * @Route(&quot;/Blog&quot;)
 *      * /
 *     class Blog
 *     {
 *         /**
 *          * @Route(&quot;/&quot;, name=&quot;blog_index&quot;)
 *          * /
 *         public function index()
 *         {
 *         }
 *         /**
 *          * @Route(&quot;/{id}&quot;, name=&quot;blog_post&quot;, requirements = {&quot;id&quot; = &quot;\d+&quot;})
 *          * /
 *         public function show()
 *         {
 *         }
 *     }
 *
 * On PHP 8, the annotation class can be used as an attribute as well:
 *     #[Route('/Blog')]
 *     class Blog
 *     {
 *         #[Route('/', name: 'blog_index')]
 *         public function index()
 *         {
 *         }
 *         #[Route('/{id}', name: 'blog_post', requirements: [&quot;id&quot; =&gt; '\d+'])]
 *         public function show()
 *         {
 *         }
 *     }

 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 * @author Alexander M. Turek &lt;me@derrabus.de&gt;
 */
abstract class AnnotationClassLoader implements LoaderInterface
{
    protected $reader;
    protected $env;

    /**
     * @var string
     */
    protected $routeAnnotationClass = RouteAnnotation::class;

    /**
     * @var int
     */
    protected $defaultRouteIndex = 0;

    public function __construct(?Reader $reader = null, ?string $env = null)
    {
        $this-&gt;reader = $reader;
        $this-&gt;env = $env;
    }

    /**
     * Sets the annotation class to read route properties from.
     */
    public function setRouteAnnotationClass(string $class)
    {
        $this-&gt;routeAnnotationClass = $class;
    }

    /**
     * Loads from annotations from a class.
     *
     * @param string $class A class name
     *
     * @return RouteCollection
     *
     * @throws \InvalidArgumentException When route can't be parsed
     */
    public function load($class, ?string $type = null)
    {
        if (!class_exists($class)) {
            throw new \InvalidArgumentException(sprintf('Class &quot;%s&quot; does not exist.', $class));
        }

        $class = new \ReflectionClass($class);
        if ($class-&gt;isAbstract()) {
            throw new \InvalidArgumentException(sprintf('Annotations from class &quot;%s&quot; cannot be read as it is abstract.', $class-&gt;getName()));
        }

        $globals = $this-&gt;getGlobals($class);

        $collection = new RouteCollection();
        $collection-&gt;addResource(new FileResource($class-&gt;getFileName()));

        if ($globals['env'] &amp;&amp; $this-&gt;env !== $globals['env']) {
            return $collection;
        }

        foreach ($class-&gt;getMethods() as $method) {
            $this-&gt;defaultRouteIndex = 0;
            foreach ($this-&gt;getAnnotations($method) as $annot) {
                $this-&gt;addRoute($collection, $annot, $globals, $class, $method);
            }
        }

        if (0 === $collection-&gt;count() &amp;&amp; $class-&gt;hasMethod('__invoke')) {
            $globals = $this-&gt;resetGlobals();
            foreach ($this-&gt;getAnnotations($class) as $annot) {
                $this-&gt;addRoute($collection, $annot, $globals, $class, $class-&gt;getMethod('__invoke'));
            }
        }

        return $collection;
    }

    /**
     * @param RouteAnnotation $annot or an object that exposes a similar interface
     */
    protected function addRoute(RouteCollection $collection, object $annot, array $globals, \ReflectionClass $class, \ReflectionMethod $method)
    {
        if ($annot-&gt;getEnv() &amp;&amp; $annot-&gt;getEnv() !== $this-&gt;env) {
            return;
        }

        $name = $annot-&gt;getName();
        if (null === $name) {
            $name = $this-&gt;getDefaultRouteName($class, $method);
        }
        $name = $globals['name'].$name;

        $requirements = $annot-&gt;getRequirements();

        foreach ($requirements as $placeholder =&gt; $requirement) {
            if (\is_int($placeholder)) {
                throw new \InvalidArgumentException(sprintf('A placeholder name must be a string (%d given). Did you forget to specify the placeholder key for the requirement &quot;%s&quot; of route &quot;%s&quot; in &quot;%s::%s()&quot;?', $placeholder, $requirement, $name, $class-&gt;getName(), $method-&gt;getName()));
            }
        }

        $defaults = array_replace($globals['defaults'], $annot-&gt;getDefaults());
        $requirements = array_replace($globals['requirements'], $requirements);
        $options = array_replace($globals['options'], $annot-&gt;getOptions());
        $schemes = array_merge($globals['schemes'], $annot-&gt;getSchemes());
        $methods = array_merge($globals['methods'], $annot-&gt;getMethods());

        $host = $annot-&gt;getHost();
        if (null === $host) {
            $host = $globals['host'];
        }

        $condition = $annot-&gt;getCondition() ?? $globals['condition'];
        $priority = $annot-&gt;getPriority() ?? $globals['priority'];

        $path = $annot-&gt;getLocalizedPaths() ?: $annot-&gt;getPath();
        $prefix = $globals['localized_paths'] ?: $globals['path'];
        $paths = [];

        if (\is_array($path)) {
            if (!\is_array($prefix)) {
                foreach ($path as $locale =&gt; $localePath) {
                    $paths[$locale] = $prefix.$localePath;
                }
            } elseif ($missing = array_diff_key($prefix, $path)) {
                throw new \LogicException(sprintf('Route to &quot;%s&quot; is missing paths for locale(s) &quot;%s&quot;.', $class-&gt;name.'::'.$method-&gt;name, implode('&quot;, &quot;', array_keys($missing))));
            } else {
                foreach ($path as $locale =&gt; $localePath) {
                    if (!isset($prefix[$locale])) {
                        throw new \LogicException(sprintf('Route to &quot;%s&quot; with locale &quot;%s&quot; is missing a corresponding prefix in class &quot;%s&quot;.', $method-&gt;name, $locale, $class-&gt;name));
                    }

                    $paths[$locale] = $prefix[$locale].$localePath;
                }
            }
        } elseif (\is_array($prefix)) {
            foreach ($prefix as $locale =&gt; $localePrefix) {
                $paths[$locale] = $localePrefix.$path;
            }
        } else {
            $paths[] = $prefix.$path;
        }

        foreach ($method-&gt;getParameters() as $param) {
            if (isset($defaults[$param-&gt;name]) || !$param-&gt;isDefaultValueAvailable()) {
                continue;
            }
            foreach ($paths as $locale =&gt; $path) {
                if (preg_match(sprintf('/\{%s(?:&lt;.*?&gt;)?\}/', preg_quote($param-&gt;name)), $path)) {
                    $defaults[$param-&gt;name] = $param-&gt;getDefaultValue();
                    break;
                }
            }
        }

        foreach ($paths as $locale =&gt; $path) {
            $route = $this-&gt;createRoute($path, $defaults, $requirements, $options, $host, $schemes, $methods, $condition);
            $this-&gt;configureRoute($route, $class, $method, $annot);
            if (0 !== $locale) {
                $route-&gt;setDefault('_locale', $locale);
                $route-&gt;setRequirement('_locale', preg_quote($locale));
                $route-&gt;setDefault('_canonical_route', $name);
                $collection-&gt;add($name.'.'.$locale, $route, $priority);
            } else {
                $collection-&gt;add($name, $route, $priority);
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function supports($resource, ?string $type = null)
    {
        return \is_string($resource) &amp;&amp; preg_match('/^(?:\\\\?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)+$/', $resource) &amp;&amp; (!$type || 'annotation' === $type);
    }

    /**
     * {@inheritdoc}
     */
    public function setResolver(LoaderResolverInterface $resolver)
    {
    }

    /**
     * {@inheritdoc}
     */
    public function getResolver()
    {
    }

    /**
     * Gets the default route name for a class method.
     *
     * @return string
     */
    protected function getDefaultRouteName(\ReflectionClass $class, \ReflectionMethod $method)
    {
        $name = str_replace('\\', '_', $class-&gt;name).'_'.$method-&gt;name;
        $name = \function_exists('mb_strtolower') &amp;&amp; preg_match('//u', $name) ? mb_strtolower($name, 'UTF-8') : strtolower($name);
        if ($this-&gt;defaultRouteIndex &gt; 0) {
            $name .= '_'.$this-&gt;defaultRouteIndex;
        }
        ++$this-&gt;defaultRouteIndex;

        return $name;
    }

    protected function getGlobals(\ReflectionClass $class)
    {
        $globals = $this-&gt;resetGlobals();

        $annot = null;
        if (\PHP_VERSION_ID &gt;= 80000 &amp;&amp; ($attribute = $class-&gt;getAttributes($this-&gt;routeAnnotationClass, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null)) {
            $annot = $attribute-&gt;newInstance();
        }
        if (!$annot &amp;&amp; $this-&gt;reader) {
            $annot = $this-&gt;reader-&gt;getClassAnnotation($class, $this-&gt;routeAnnotationClass);
        }

        if ($annot) {
            if (null !== $annot-&gt;getName()) {
                $globals['name'] = $annot-&gt;getName();
            }

            if (null !== $annot-&gt;getPath()) {
                $globals['path'] = $annot-&gt;getPath();
            }

            $globals['localized_paths'] = $annot-&gt;getLocalizedPaths();

            if (null !== $annot-&gt;getRequirements()) {
                $globals['requirements'] = $annot-&gt;getRequirements();
            }

            if (null !== $annot-&gt;getOptions()) {
                $globals['options'] = $annot-&gt;getOptions();
            }

            if (null !== $annot-&gt;getDefaults()) {
                $globals['defaults'] = $annot-&gt;getDefaults();
            }

            if (null !== $annot-&gt;getSchemes()) {
                $globals['schemes'] = $annot-&gt;getSchemes();
            }

            if (null !== $annot-&gt;getMethods()) {
                $globals['methods'] = $annot-&gt;getMethods();
            }

            if (null !== $annot-&gt;getHost()) {
                $globals['host'] = $annot-&gt;getHost();
            }

            if (null !== $annot-&gt;getCondition()) {
                $globals['condition'] = $annot-&gt;getCondition();
            }

            $globals['priority'] = $annot-&gt;getPriority() ?? 0;
            $globals['env'] = $annot-&gt;getEnv();

            foreach ($globals['requirements'] as $placeholder =&gt; $requirement) {
                if (\is_int($placeholder)) {
                    throw new \InvalidArgumentException(sprintf('A placeholder name must be a string (%d given). Did you forget to specify the placeholder key for the requirement &quot;%s&quot; in &quot;%s&quot;?', $placeholder, $requirement, $class-&gt;getName()));
                }
            }
        }

        return $globals;
    }

    private function resetGlobals(): array
    {
        return [
            'path' =&gt; null,
            'localized_paths' =&gt; [],
            'requirements' =&gt; [],
            'options' =&gt; [],
            'defaults' =&gt; [],
            'schemes' =&gt; [],
            'methods' =&gt; [],
            'host' =&gt; '',
            'condition' =&gt; '',
            'name' =&gt; '',
            'priority' =&gt; 0,
            'env' =&gt; null,
        ];
    }

    protected function createRoute(string $path, array $defaults, array $requirements, array $options, ?string $host, array $schemes, array $methods, ?string $condition)
    {
        return new Route($path, $defaults, $requirements, $options, $host, $schemes, $methods, $condition);
    }

    abstract protected function configureRoute(Route $route, \ReflectionClass $class, \ReflectionMethod $method, object $annot);

    /**
     * @param \ReflectionClass|\ReflectionMethod $reflection
     *
     * @return iterable&lt;int, RouteAnnotation&gt;
     */
    private function getAnnotations(object $reflection): iterable
    {
        if (\PHP_VERSION_ID &gt;= 80000) {
            foreach ($reflection-&gt;getAttributes($this-&gt;routeAnnotationClass, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
                yield $attribute-&gt;newInstance();
            }
        }

        if (!$this-&gt;reader) {
            return;
        }

        $anntotations = $reflection instanceof \ReflectionClass
            ? $this-&gt;reader-&gt;getClassAnnotations($reflection)
            : $this-&gt;reader-&gt;getMethodAnnotations($reflection);

        foreach ($anntotations as $annotation) {
            if ($annotation instanceof $this-&gt;routeAnnotationClass) {
                yield $annotation;
            }
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>