first commit

vendor/symfony/http-kernel/DependencyInjection/AddAnnotatedClassesToCachePass.php

@@ -0,0 +1,145 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Composer\Autoload\ClassLoader;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\ErrorHandler\DebugClassLoader;
+use Symfony\Component\HttpKernel\Kernel;
+
+/**
+ * Sets the classes to compile in the cache for the container.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class AddAnnotatedClassesToCachePass implements CompilerPassInterface
+{
+    private Kernel $kernel;
+
+    public function __construct(Kernel $kernel)
+    {
+        $this->kernel = $kernel;
+    }
+
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $annotatedClasses = [];
+        foreach ($container->getExtensions() as $extension) {
+            if ($extension instanceof Extension) {
+                $annotatedClasses[] = $extension->getAnnotatedClassesToCompile();
+            }
+        }
+
+        $annotatedClasses = array_merge($this->kernel->getAnnotatedClassesToCompile(), ...$annotatedClasses);
+
+        $existingClasses = $this->getClassesInComposerClassMaps();
+
+        $annotatedClasses = $container->getParameterBag()->resolveValue($annotatedClasses);
+        $this->kernel->setAnnotatedClassCache($this->expandClasses($annotatedClasses, $existingClasses));
+    }
+
+    /**
+     * Expands the given class patterns using a list of existing classes.
+     *
+     * @param array $patterns The class patterns to expand
+     * @param array $classes  The existing classes to match against the patterns
+     */
+    private function expandClasses(array $patterns, array $classes): array
+    {
+        $expanded = [];
+
+        // Explicit classes declared in the patterns are returned directly
+        foreach ($patterns as $key => $pattern) {
+            if (!str_ends_with($pattern, '\\') && !str_contains($pattern, '*')) {
+                unset($patterns[$key]);
+                $expanded[] = ltrim($pattern, '\\');
+            }
+        }
+
+        // Match patterns with the classes list
+        $regexps = $this->patternsToRegexps($patterns);
+
+        foreach ($classes as $class) {
+            $class = ltrim($class, '\\');
+
+            if ($this->matchAnyRegexps($class, $regexps)) {
+                $expanded[] = $class;
+            }
+        }
+
+        return array_unique($expanded);
+    }
+
+    private function getClassesInComposerClassMaps(): array
+    {
+        $classes = [];
+
+        foreach (spl_autoload_functions() as $function) {
+            if (!\is_array($function)) {
+                continue;
+            }
+
+            if ($function[0] instanceof DebugClassLoader) {
+                $function = $function[0]->getClassLoader();
+            }
+
+            if (\is_array($function) && $function[0] instanceof ClassLoader) {
+                $classes += array_filter($function[0]->getClassMap());
+            }
+        }
+
+        return array_keys($classes);
+    }
+
+    private function patternsToRegexps(array $patterns): array
+    {
+        $regexps = [];
+
+        foreach ($patterns as $pattern) {
+            // Escape user input
+            $regex = preg_quote(ltrim($pattern, '\\'));
+
+            // Wildcards * and **
+            $regex = strtr($regex, ['\\*\\*' => '.*?', '\\*' => '[^\\\\]*?']);
+
+            // If this class does not end by a slash, anchor the end
+            if (!str_ends_with($regex, '\\')) {
+                $regex .= '$';
+            }
+
+            $regexps[] = '{^\\\\'.$regex.'}';
+        }
+
+        return $regexps;
+    }
+
+    private function matchAnyRegexps(string $class, array $regexps): bool
+    {
+        $isTest = str_contains($class, 'Test');
+
+        foreach ($regexps as $regex) {
+            if ($isTest && !str_contains($regex, 'Test')) {
+                continue;
+            }
+
+            if (preg_match($regex, '\\'.$class)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/ConfigurableExtension.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * This extension sub-class provides first-class integration with the
+ * Config/Definition Component.
+ *
+ * You can use this as base class if
+ *
+ *    a) you use the Config/Definition component for configuration,
+ *    b) your configuration class is named "Configuration", and
+ *    c) the configuration class resides in the DependencyInjection sub-folder.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+abstract class ConfigurableExtension extends Extension
+{
+    final public function load(array $configs, ContainerBuilder $container): void
+    {
+        $this->loadInternal($this->processConfiguration($this->getConfiguration($configs, $container), $configs), $container);
+    }
+
+    /**
+     * Configures the passed container according to the merged configuration.
+     *
+     * @return void
+     */
+    abstract protected function loadInternal(array $mergedConfig, ContainerBuilder $container);
+}

vendor/symfony/http-kernel/DependencyInjection/ControllerArgumentValueResolverPass.php

@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
+use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Compiler\PriorityTaggedServiceTrait;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpKernel\Controller\ArgumentResolver\TraceableValueResolver;
+use Symfony\Component\Stopwatch\Stopwatch;
+
+/**
+ * Gathers and configures the argument value resolvers.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+class ControllerArgumentValueResolverPass implements CompilerPassInterface
+{
+    use PriorityTaggedServiceTrait;
+
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('argument_resolver')) {
+            return;
+        }
+
+        $definitions = $container->getDefinitions();
+        $namedResolvers = $this->findAndSortTaggedServices(new TaggedIteratorArgument('controller.targeted_value_resolver', 'name', needsIndexes: true), $container);
+        $resolvers = $this->findAndSortTaggedServices(new TaggedIteratorArgument('controller.argument_value_resolver', 'name', needsIndexes: true), $container);
+
+        foreach ($resolvers as $name => $resolver) {
+            if ($definitions[(string) $resolver]->hasTag('controller.targeted_value_resolver')) {
+                unset($resolvers[$name]);
+            } else {
+                $namedResolvers[$name] ??= clone $resolver;
+            }
+        }
+
+        if ($container->getParameter('kernel.debug') && class_exists(Stopwatch::class) && $container->has('debug.stopwatch')) {
+            foreach ($resolvers as $name => $resolver) {
+                $resolvers[$name] = new Reference('.debug.value_resolver.'.$resolver);
+                $container->register('.debug.value_resolver.'.$resolver, TraceableValueResolver::class)
+                    ->setArguments([$resolver, new Reference('debug.stopwatch')]);
+            }
+            foreach ($namedResolvers as $name => $resolver) {
+                $namedResolvers[$name] = new Reference('.debug.value_resolver.'.$resolver);
+                $container->register('.debug.value_resolver.'.$resolver, TraceableValueResolver::class)
+                    ->setArguments([$resolver, new Reference('debug.stopwatch')]);
+            }
+        }
+
+        $container
+            ->getDefinition('argument_resolver')
+            ->replaceArgument(1, new IteratorArgument(array_values($resolvers)))
+            ->setArgument(2, new ServiceLocatorArgument($namedResolvers))
+        ;
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/Extension.php

@@ -0,0 +1,44 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Extension\Extension as BaseExtension;
+
+/**
+ * Allow adding classes to the class cache.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class Extension extends BaseExtension
+{
+    private array $annotatedClasses = [];
+
+    /**
+     * Gets the annotated classes to cache.
+     */
+    public function getAnnotatedClassesToCompile(): array
+    {
+        return $this->annotatedClasses;
+    }
+
+    /**
+     * Adds annotated classes to the class cache.
+     *
+     * @param array $annotatedClasses An array of class patterns
+     *
+     * @return void
+     */
+    public function addAnnotatedClassesToCompile(array $annotatedClasses)
+    {
+        $this->annotatedClasses = array_merge($this->annotatedClasses, $annotatedClasses);
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/FragmentRendererPass.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpKernel\Fragment\FragmentRendererInterface;
+
+/**
+ * Adds services tagged kernel.fragment_renderer as HTTP content rendering strategies.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class FragmentRendererPass implements CompilerPassInterface
+{
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('fragment.handler')) {
+            return;
+        }
+
+        $definition = $container->getDefinition('fragment.handler');
+        $renderers = [];
+        foreach ($container->findTaggedServiceIds('kernel.fragment_renderer', true) as $id => $tags) {
+            $def = $container->getDefinition($id);
+            $class = $container->getParameterBag()->resolveValue($def->getClass());
+
+            if (!$r = $container->getReflectionClass($class)) {
+                throw new InvalidArgumentException(sprintf('Class "%s" used for service "%s" cannot be found.', $class, $id));
+            }
+            if (!$r->isSubclassOf(FragmentRendererInterface::class)) {
+                throw new InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, FragmentRendererInterface::class));
+            }
+
+            foreach ($tags as $tag) {
+                $renderers[$tag['alias']] = new Reference($id);
+            }
+        }
+
+        $definition->replaceArgument(0, ServiceLocatorTagPass::register($container, $renderers));
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/LazyLoadingFragmentHandler.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Psr\Container\ContainerInterface;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+use Symfony\Component\HttpKernel\Fragment\FragmentHandler;
+
+/**
+ * Lazily loads fragment renderers from the dependency injection container.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class LazyLoadingFragmentHandler extends FragmentHandler
+{
+    private ContainerInterface $container;
+
+    /**
+     * @var array<string, bool>
+     */
+    private array $initialized = [];
+
+    public function __construct(ContainerInterface $container, RequestStack $requestStack, bool $debug = false)
+    {
+        $this->container = $container;
+
+        parent::__construct($requestStack, [], $debug);
+    }
+
+    public function render(string|ControllerReference $uri, string $renderer = 'inline', array $options = []): ?string
+    {
+        if (!isset($this->initialized[$renderer]) && $this->container->has($renderer)) {
+            $this->addRenderer($this->container->get($renderer));
+            $this->initialized[$renderer] = true;
+        }
+
+        return parent::render($uri, $renderer, $options);
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/LoggerPass.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Psr\Log\LoggerInterface;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Log\Logger;
+
+/**
+ * Registers the default logger if necessary.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class LoggerPass implements CompilerPassInterface
+{
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $container->setAlias(LoggerInterface::class, 'logger');
+
+        if ($container->has('logger')) {
+            return;
+        }
+
+        if ($debug = $container->getParameter('kernel.debug')) {
+            $debug = $container->hasParameter('kernel.runtime_mode.web')
+                ? $container->getParameter('kernel.runtime_mode.web')
+                : !\in_array(\PHP_SAPI, ['cli', 'phpdbg', 'embed'], true);
+        }
+
+        $container->register('logger', Logger::class)
+            ->setArguments([null, null, null, new Reference(RequestStack::class), $debug]);
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/MergeExtensionConfigurationPass.php

@@ -0,0 +1,44 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Compiler\MergeExtensionConfigurationPass as BaseMergeExtensionConfigurationPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Ensures certain extensions are always loaded.
+ *
+ * @author Kris Wallsmith <kris@symfony.com>
+ */
+class MergeExtensionConfigurationPass extends BaseMergeExtensionConfigurationPass
+{
+    private array $extensions;
+
+    /**
+     * @param string[] $extensions
+     */
+    public function __construct(array $extensions)
+    {
+        $this->extensions = $extensions;
+    }
+
+    public function process(ContainerBuilder $container): void
+    {
+        foreach ($this->extensions as $extension) {
+            if (!\count($container->getExtensionConfig($extension))) {
+                $container->loadFromExtension($extension, []);
+            }
+        }
+
+        parent::process($container);
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/RegisterControllerArgumentLocatorsPass.php

@@ -0,0 +1,239 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\DependencyInjection\Attribute\AutowireCallable;
+use Symfony\Component\DependencyInjection\Attribute\Target;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\TypedReference;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Symfony\Component\VarExporter\ProxyHelper;
+
+/**
+ * Creates the service-locators required by ServiceValueResolver.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class RegisterControllerArgumentLocatorsPass implements CompilerPassInterface
+{
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('argument_resolver.service') && !$container->hasDefinition('argument_resolver.not_tagged_controller')) {
+            return;
+        }
+
+        $parameterBag = $container->getParameterBag();
+        $controllers = [];
+        $controllerClasses = [];
+
+        $publicAliases = [];
+        foreach ($container->getAliases() as $id => $alias) {
+            if ($alias->isPublic() && !$alias->isPrivate()) {
+                $publicAliases[(string) $alias][] = $id;
+            }
+        }
+
+        $emptyAutowireAttributes = class_exists(Autowire::class) ? null : [];
+
+        foreach ($container->findTaggedServiceIds('controller.service_arguments', true) as $id => $tags) {
+            $def = $container->getDefinition($id);
+            $def->setPublic(true);
+            $class = $def->getClass();
+            $autowire = $def->isAutowired();
+            $bindings = $def->getBindings();
+
+            // resolve service class, taking parent definitions into account
+            while ($def instanceof ChildDefinition) {
+                $def = $container->findDefinition($def->getParent());
+                $class = $class ?: $def->getClass();
+                $bindings += $def->getBindings();
+            }
+            $class = $parameterBag->resolveValue($class);
+
+            if (!$r = $container->getReflectionClass($class)) {
+                throw new InvalidArgumentException(sprintf('Class "%s" used for service "%s" cannot be found.', $class, $id));
+            }
+
+            $controllerClasses[] = $class;
+
+            // get regular public methods
+            $methods = [];
+            $arguments = [];
+            foreach ($r->getMethods(\ReflectionMethod::IS_PUBLIC) as $r) {
+                if ('setContainer' === $r->name) {
+                    continue;
+                }
+                if (!$r->isConstructor() && !$r->isDestructor() && !$r->isAbstract()) {
+                    $methods[strtolower($r->name)] = [$r, $r->getParameters()];
+                }
+            }
+
+            // validate and collect explicit per-actions and per-arguments service references
+            foreach ($tags as $attributes) {
+                if (!isset($attributes['action']) && !isset($attributes['argument']) && !isset($attributes['id'])) {
+                    $autowire = true;
+                    continue;
+                }
+                foreach (['action', 'argument', 'id'] as $k) {
+                    if (!isset($attributes[$k][0])) {
+                        throw new InvalidArgumentException(sprintf('Missing "%s" attribute on tag "controller.service_arguments" %s for service "%s".', $k, json_encode($attributes, \JSON_UNESCAPED_UNICODE), $id));
+                    }
+                }
+                if (!isset($methods[$action = strtolower($attributes['action'])])) {
+                    throw new InvalidArgumentException(sprintf('Invalid "action" attribute on tag "controller.service_arguments" for service "%s": no public "%s()" method found on class "%s".', $id, $attributes['action'], $class));
+                }
+                [$r, $parameters] = $methods[$action];
+                $found = false;
+
+                foreach ($parameters as $p) {
+                    if ($attributes['argument'] === $p->name) {
+                        if (!isset($arguments[$r->name][$p->name])) {
+                            $arguments[$r->name][$p->name] = $attributes['id'];
+                        }
+                        $found = true;
+                        break;
+                    }
+                }
+
+                if (!$found) {
+                    throw new InvalidArgumentException(sprintf('Invalid "controller.service_arguments" tag for service "%s": method "%s()" has no "%s" argument on class "%s".', $id, $r->name, $attributes['argument'], $class));
+                }
+            }
+
+            foreach ($methods as [$r, $parameters]) {
+                /** @var \ReflectionMethod $r */
+
+                // create a per-method map of argument-names to service/type-references
+                $args = [];
+                foreach ($parameters as $p) {
+                    /** @var \ReflectionParameter $p */
+                    $type = preg_replace('/(^|[(|&])\\\\/', '\1', $target = ltrim(ProxyHelper::exportType($p) ?? '', '?'));
+                    $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
+                    $autowireAttributes = $autowire ? $emptyAutowireAttributes : [];
+                    $parsedName = $p->name;
+                    $k = null;
+
+                    if (isset($arguments[$r->name][$p->name])) {
+                        $target = $arguments[$r->name][$p->name];
+                        if ('?' !== $target[0]) {
+                            $invalidBehavior = ContainerInterface::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE;
+                        } elseif ('' === $target = (string) substr($target, 1)) {
+                            throw new InvalidArgumentException(sprintf('A "controller.service_arguments" tag must have non-empty "id" attributes for service "%s".', $id));
+                        } elseif ($p->allowsNull() && !$p->isOptional()) {
+                            $invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
+                        }
+                    } elseif (isset($bindings[$bindingName = $type.' $'.$name = Target::parseName($p, $k, $parsedName)])
+                        || isset($bindings[$bindingName = $type.' $'.$parsedName])
+                        || isset($bindings[$bindingName = '$'.$name])
+                        || isset($bindings[$bindingName = $type])
+                    ) {
+                        $binding = $bindings[$bindingName];
+
+                        [$bindingValue, $bindingId, , $bindingType, $bindingFile] = $binding->getValues();
+                        $binding->setValues([$bindingValue, $bindingId, true, $bindingType, $bindingFile]);
+
+                        $args[$p->name] = $bindingValue;
+
+                        continue;
+                    } elseif (!$autowire || (!($autowireAttributes ??= $p->getAttributes(Autowire::class, \ReflectionAttribute::IS_INSTANCEOF)) && (!$type || '\\' !== $target[0]))) {
+                        continue;
+                    } elseif (is_subclass_of($type, \UnitEnum::class)) {
+                        // do not attempt to register enum typed arguments if not already present in bindings
+                        continue;
+                    } elseif (!$p->allowsNull()) {
+                        $invalidBehavior = ContainerInterface::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE;
+                    }
+
+                    if (Request::class === $type || SessionInterface::class === $type || Response::class === $type) {
+                        continue;
+                    }
+
+                    if ($autowireAttributes) {
+                        $attribute = $autowireAttributes[0]->newInstance();
+                        $value = $parameterBag->resolveValue($attribute->value);
+
+                        if ($attribute instanceof AutowireCallable) {
+                            $value = $attribute->buildDefinition($value, $type, $p);
+                        }
+
+                        if ($value instanceof Reference) {
+                            $args[$p->name] = $type ? new TypedReference($value, $type, $invalidBehavior, $p->name) : new Reference($value, $invalidBehavior);
+                        } else {
+                            $args[$p->name] = new Reference('.value.'.$container->hash($value));
+                            $container->register((string) $args[$p->name], 'mixed')
+                                ->setFactory('current')
+                                ->addArgument([$value]);
+                        }
+
+                        continue;
+                    }
+
+                    if ($type && !$p->isOptional() && !$p->allowsNull() && !class_exists($type) && !interface_exists($type, false)) {
+                        $message = sprintf('Cannot determine controller argument for "%s::%s()": the $%s argument is type-hinted with the non-existent class or interface: "%s".', $class, $r->name, $p->name, $type);
+
+                        // see if the type-hint lives in the same namespace as the controller
+                        if (0 === strncmp($type, $class, strrpos($class, '\\'))) {
+                            $message .= ' Did you forget to add a use statement?';
+                        }
+
+                        $container->register($erroredId = '.errored.'.$container->hash($message), $type)
+                            ->addError($message);
+
+                        $args[$p->name] = new Reference($erroredId, ContainerInterface::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE);
+                    } else {
+                        $target = preg_replace('/(^|[(|&])\\\\/', '\1', $target);
+                        $args[$p->name] = $type ? new TypedReference($target, $type, $invalidBehavior, Target::parseName($p)) : new Reference($target, $invalidBehavior);
+                    }
+                }
+                // register the maps as a per-method service-locators
+                if ($args) {
+                    $controllers[$id.'::'.$r->name] = ServiceLocatorTagPass::register($container, $args);
+
+                    foreach ($publicAliases[$id] ?? [] as $alias) {
+                        $controllers[$alias.'::'.$r->name] = clone $controllers[$id.'::'.$r->name];
+                    }
+                }
+            }
+        }
+
+        $controllerLocatorRef = ServiceLocatorTagPass::register($container, $controllers);
+
+        if ($container->hasDefinition('argument_resolver.service')) {
+            $container->getDefinition('argument_resolver.service')
+                ->replaceArgument(0, $controllerLocatorRef);
+        }
+
+        if ($container->hasDefinition('argument_resolver.not_tagged_controller')) {
+            $container->getDefinition('argument_resolver.not_tagged_controller')
+                ->replaceArgument(0, $controllerLocatorRef);
+        }
+
+        $container->setAlias('argument_resolver.controller_locator', (string) $controllerLocatorRef);
+
+        if ($container->hasDefinition('controller_resolver')) {
+            $container->getDefinition('controller_resolver')
+                ->addMethodCall('allowControllers', [array_unique($controllerClasses)]);
+        }
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/RegisterLocaleAwareServicesPass.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Register all services that have the "kernel.locale_aware" tag into the listener.
+ *
+ * @author Pierre Bobiet <pierrebobiet@gmail.com>
+ */
+class RegisterLocaleAwareServicesPass implements CompilerPassInterface
+{
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('locale_aware_listener')) {
+            return;
+        }
+
+        $services = [];
+
+        foreach ($container->findTaggedServiceIds('kernel.locale_aware') as $id => $tags) {
+            $services[] = new Reference($id);
+        }
+
+        if (!$services) {
+            $container->removeDefinition('locale_aware_listener');
+
+            return;
+        }
+
+        $container
+            ->getDefinition('locale_aware_listener')
+            ->setArgument(0, new IteratorArgument($services))
+        ;
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/RemoveEmptyControllerArgumentLocatorsPass.php

@@ -0,0 +1,71 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Removes empty service-locators registered for ServiceValueResolver.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class RemoveEmptyControllerArgumentLocatorsPass implements CompilerPassInterface
+{
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $controllerLocator = $container->findDefinition('argument_resolver.controller_locator');
+        $controllers = $controllerLocator->getArgument(0);
+
+        foreach ($controllers as $controller => $argumentRef) {
+            $argumentLocator = $container->getDefinition((string) $argumentRef->getValues()[0]);
+
+            if (!$argumentLocator->getArgument(0)) {
+                // remove empty argument locators
+                $reason = sprintf('Removing service-argument resolver for controller "%s": no corresponding services exist for the referenced types.', $controller);
+            } else {
+                // any methods listed for call-at-instantiation cannot be actions
+                $reason = false;
+                [$id, $action] = explode('::', $controller);
+
+                if ($container->hasAlias($id)) {
+                    continue;
+                }
+
+                $controllerDef = $container->getDefinition($id);
+                foreach ($controllerDef->getMethodCalls() as [$method]) {
+                    if (0 === strcasecmp($action, $method)) {
+                        $reason = sprintf('Removing method "%s" of service "%s" from controller candidates: the method is called at instantiation, thus cannot be an action.', $action, $id);
+                        break;
+                    }
+                }
+                if (!$reason) {
+                    // see Symfony\Component\HttpKernel\Controller\ContainerControllerResolver
+                    $controllers[$id.':'.$action] = $argumentRef;
+
+                    if ('__invoke' === $action) {
+                        $controllers[$id] = $argumentRef;
+                    }
+                    continue;
+                }
+            }
+
+            unset($controllers[$controller]);
+            $container->log($this, $reason);
+        }
+
+        $controllerLocator->replaceArgument(0, $controllers);
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/ResettableServicePass.php

@@ -0,0 +1,68 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * @author Alexander M. Turek <me@derrabus.de>
+ */
+class ResettableServicePass implements CompilerPassInterface
+{
+    /**
+     * @return void
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->has('services_resetter')) {
+            return;
+        }
+
+        $services = $methods = [];
+
+        foreach ($container->findTaggedServiceIds('kernel.reset', true) as $id => $tags) {
+            $services[$id] = new Reference($id, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE);
+
+            foreach ($tags as $attributes) {
+                if (!isset($attributes['method'])) {
+                    throw new RuntimeException(sprintf('Tag "kernel.reset" requires the "method" attribute to be set on service "%s".', $id));
+                }
+
+                if (!isset($methods[$id])) {
+                    $methods[$id] = [];
+                }
+
+                if ('ignore' === ($attributes['on_invalid'] ?? null)) {
+                    $attributes['method'] = '?'.$attributes['method'];
+                }
+
+                $methods[$id][] = $attributes['method'];
+            }
+        }
+
+        if (!$services) {
+            $container->removeAlias('services_resetter');
+            $container->removeDefinition('services_resetter');
+
+            return;
+        }
+
+        $container->findDefinition('services_resetter')
+            ->setArgument(0, new IteratorArgument($services))
+            ->setArgument(1, $methods);
+    }
+}

vendor/symfony/http-kernel/DependencyInjection/ServicesResetter.php

@@ -0,0 +1,61 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpKernel\DependencyInjection;
+
+use ProxyManager\Proxy\LazyLoadingInterface;
+use Symfony\Component\VarExporter\LazyObjectInterface;
+use Symfony\Contracts\Service\ResetInterface;
+
+/**
+ * Resets provided services.
+ *
+ * @author Alexander M. Turek <me@derrabus.de>
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class ServicesResetter implements ResetInterface
+{
+    private \Traversable $resettableServices;
+    private array $resetMethods;
+
+    /**
+     * @param \Traversable<string, object>   $resettableServices
+     * @param array<string, string|string[]> $resetMethods
+     */
+    public function __construct(\Traversable $resettableServices, array $resetMethods)
+    {
+        $this->resettableServices = $resettableServices;
+        $this->resetMethods = $resetMethods;
+    }
+
+    public function reset(): void
+    {
+        foreach ($this->resettableServices as $id => $service) {
+            if ($service instanceof LazyObjectInterface && !$service->isLazyObjectInitialized(true)) {
+                continue;
+            }
+
+            if ($service instanceof LazyLoadingInterface && !$service->isProxyInitialized()) {
+                continue;
+            }
+
+            foreach ((array) $this->resetMethods[$id] as $resetMethod) {
+                if ('?' === $resetMethod[0] && !method_exists($service, $resetMethod = substr($resetMethod, 1))) {
+                    continue;
+                }
+
+                $service->$resetMethod();
+            }
+        }
+    }
+}