first commit

vendor/symfony/http-kernel/Controller/ArgumentResolver/BackedEnumValueResolver.php

@@ -0,0 +1,93 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Attempt to resolve backed enum cases from request attributes, for a route path parameter,
+ * leading to a 404 Not Found if the attribute value isn't a valid backing value for the enum type.
+ *
+ * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
+ *
+ * @final since Symfony 6.2
+ */
+class BackedEnumValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        if (!is_subclass_of($argument->getType(), \BackedEnum::class)) {
+            return false;
+        }
+
+        if ($argument->isVariadic()) {
+            // only target route path parameters, which cannot be variadic.
+            return false;
+        }
+
+        // do not support if no value can be resolved at all
+        // letting the \Symfony\Component\HttpKernel\Controller\ArgumentResolver\DefaultValueResolver be used
+        // or \Symfony\Component\HttpKernel\Controller\ArgumentResolver fail with a meaningful error.
+        return $request->attributes->has($argument->getName());
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): iterable
+    {
+        if (!is_subclass_of($argument->getType(), \BackedEnum::class)) {
+            return [];
+        }
+
+        if ($argument->isVariadic()) {
+            // only target route path parameters, which cannot be variadic.
+            return [];
+        }
+
+        // do not support if no value can be resolved at all
+        // letting the \Symfony\Component\HttpKernel\Controller\ArgumentResolver\DefaultValueResolver be used
+        // or \Symfony\Component\HttpKernel\Controller\ArgumentResolver fail with a meaningful error.
+        if (!$request->attributes->has($argument->getName())) {
+            return [];
+        }
+
+        $value = $request->attributes->get($argument->getName());
+
+        if (null === $value) {
+            return [null];
+        }
+
+        if ($value instanceof \BackedEnum) {
+            return [$value];
+        }
+
+        if (!\is_int($value) && !\is_string($value)) {
+            throw new \LogicException(sprintf('Could not resolve the "%s $%s" controller argument: expecting an int or string, got "%s".', $argument->getType(), $argument->getName(), get_debug_type($value)));
+        }
+
+        /** @var class-string<\BackedEnum> $enumType */
+        $enumType = $argument->getType();
+
+        try {
+            return [$enumType::from($value)];
+        } catch (\ValueError|\TypeError $e) {
+            throw new NotFoundHttpException(sprintf('Could not resolve the "%s $%s" controller argument: ', $argument->getType(), $argument->getName()).$e->getMessage(), $e);
+        }
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/DateTimeValueResolver.php

@@ -0,0 +1,98 @@
+<?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\Controller\ArgumentResolver;
+
+use Psr\Clock\ClockInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Attribute\MapDateTime;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Convert DateTime instances from request attribute variable.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Tim Goudriaan <tim@codedmonkey.com>
+ */
+final class DateTimeValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    public function __construct(
+        private readonly ?ClockInterface $clock = null,
+    ) {
+    }
+
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        return is_a($argument->getType(), \DateTimeInterface::class, true) && $request->attributes->has($argument->getName());
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        if (!is_a($argument->getType(), \DateTimeInterface::class, true) || !$request->attributes->has($argument->getName())) {
+            return [];
+        }
+
+        $value = $request->attributes->get($argument->getName());
+        $class = \DateTimeInterface::class === $argument->getType() ? \DateTimeImmutable::class : $argument->getType();
+
+        if (!$value) {
+            if ($argument->isNullable()) {
+                return [null];
+            }
+            if (!$this->clock) {
+                return [new $class()];
+            }
+            $value = $this->clock->now();
+        }
+
+        if ($value instanceof \DateTimeInterface) {
+            return [$value instanceof $class ? $value : $class::createFromInterface($value)];
+        }
+
+        $format = null;
+
+        if ($attributes = $argument->getAttributes(MapDateTime::class, ArgumentMetadata::IS_INSTANCEOF)) {
+            $attribute = $attributes[0];
+            $format = $attribute->format;
+        }
+
+        if (null !== $format) {
+            $date = $class::createFromFormat($format, $value, $this->clock?->now()->getTimeZone());
+
+            if (($class::getLastErrors() ?: ['warning_count' => 0])['warning_count']) {
+                $date = false;
+            }
+        } else {
+            if (false !== filter_var($value, \FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {
+                $value = '@'.$value;
+            }
+            try {
+                $date = new $class($value, $this->clock?->now()->getTimeZone());
+            } catch (\Exception) {
+                $date = false;
+            }
+        }
+
+        if (!$date) {
+            throw new NotFoundHttpException(sprintf('Invalid date given for parameter "%s".', $argument->getName()));
+        }
+
+        return [$date];
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/DefaultValueResolver.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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Yields the default value defined in the action signature when no value has been given.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+final class DefaultValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        return $argument->hasDefaultValue() || (null !== $argument->getType() && $argument->isNullable() && !$argument->isVariadic());
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        if ($argument->hasDefaultValue()) {
+            return [$argument->getDefaultValue()];
+        }
+
+        if (null !== $argument->getType() && $argument->isNullable() && !$argument->isVariadic()) {
+            return [null];
+        }
+
+        return [];
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/NotTaggedControllerValueResolver.php

@@ -0,0 +1,90 @@
+<?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\Controller\ArgumentResolver;
+
+use Psr\Container\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Provides an intuitive error message when controller fails because it is not registered as a service.
+ *
+ * @author Simeon Kolev <simeon.kolev9@gmail.com>
+ */
+final class NotTaggedControllerValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    private ContainerInterface $container;
+
+    public function __construct(ContainerInterface $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        $controller = $request->attributes->get('_controller');
+
+        if (\is_array($controller) && \is_callable($controller, true) && \is_string($controller[0])) {
+            $controller = $controller[0].'::'.$controller[1];
+        } elseif (!\is_string($controller) || '' === $controller) {
+            return false;
+        }
+
+        if ('\\' === $controller[0]) {
+            $controller = ltrim($controller, '\\');
+        }
+
+        if (!$this->container->has($controller) && false !== $i = strrpos($controller, ':')) {
+            $controller = substr($controller, 0, $i).strtolower(substr($controller, $i));
+        }
+
+        return false === $this->container->has($controller);
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        $controller = $request->attributes->get('_controller');
+
+        if (\is_array($controller) && \is_callable($controller, true) && \is_string($controller[0])) {
+            $controller = $controller[0].'::'.$controller[1];
+        } elseif (!\is_string($controller) || '' === $controller) {
+            return [];
+        }
+
+        if ('\\' === $controller[0]) {
+            $controller = ltrim($controller, '\\');
+        }
+
+        if (!$this->container->has($controller)) {
+            $controller = (false !== $i = strrpos($controller, ':'))
+                ? substr($controller, 0, $i).strtolower(substr($controller, $i))
+                : $controller.'::__invoke';
+        }
+
+        if ($this->container->has($controller)) {
+            return [];
+        }
+
+        $what = sprintf('argument $%s of "%s()"', $argument->getName(), $controller);
+        $message = sprintf('Could not resolve %s, maybe you forgot to register the controller as a service or missed tagging it with the "controller.service_arguments"?', $what);
+
+        throw new RuntimeException($message);
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/QueryParameterValueResolver.php

@@ -0,0 +1,125 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Attribute\MapQueryParameter;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Resolve arguments of type: array, string, int, float, bool, \BackedEnum from query parameters.
+ *
+ * @author Ruud Kamphuis <ruud@ticketswap.com>
+ * @author Nicolas Grekas <p@tchwork.com>
+ * @author Mateusz Anders <anders_mateusz@outlook.com>
+ */
+final class QueryParameterValueResolver implements ValueResolverInterface
+{
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        if (!$attribute = $argument->getAttributesOfType(MapQueryParameter::class)[0] ?? null) {
+            return [];
+        }
+
+        $name = $attribute->name ?? $argument->getName();
+        if (!$request->query->has($name)) {
+            if ($argument->isNullable() || $argument->hasDefaultValue()) {
+                return [];
+            }
+
+            throw new NotFoundHttpException(sprintf('Missing query parameter "%s".', $name));
+        }
+
+        $value = $request->query->all()[$name];
+        $type = $argument->getType();
+
+        if (null === $attribute->filter && 'array' === $type) {
+            if (!$argument->isVariadic()) {
+                return [(array) $value];
+            }
+
+            $filtered = array_values(array_filter((array) $value, \is_array(...)));
+
+            if ($filtered !== $value && !($attribute->flags & \FILTER_NULL_ON_FAILURE)) {
+                throw new NotFoundHttpException(sprintf('Invalid query parameter "%s".', $name));
+            }
+
+            return $filtered;
+        }
+
+        $options = [
+            'flags' => $attribute->flags | \FILTER_NULL_ON_FAILURE,
+            'options' => $attribute->options,
+        ];
+
+        if ('array' === $type || $argument->isVariadic()) {
+            $value = (array) $value;
+            $options['flags'] |= \FILTER_REQUIRE_ARRAY;
+        } else {
+            $options['flags'] |= \FILTER_REQUIRE_SCALAR;
+        }
+
+        $enumType = null;
+        $filter = match ($type) {
+            'array' => \FILTER_DEFAULT,
+            'string' => \FILTER_DEFAULT,
+            'int' => \FILTER_VALIDATE_INT,
+            'float' => \FILTER_VALIDATE_FLOAT,
+            'bool' => \FILTER_VALIDATE_BOOL,
+            default => match ($enumType = is_subclass_of($type, \BackedEnum::class) ? (new \ReflectionEnum($type))->getBackingType()->getName() : null) {
+                'int' => \FILTER_VALIDATE_INT,
+                'string' => \FILTER_DEFAULT,
+                default => throw new \LogicException(sprintf('#[MapQueryParameter] cannot be used on controller argument "%s$%s" of type "%s"; one of array, string, int, float, bool or \BackedEnum should be used.', $argument->isVariadic() ? '...' : '', $argument->getName(), $type ?? 'mixed')),
+            }
+        };
+
+        $value = filter_var($value, $attribute->filter ?? $filter, $options);
+
+        if (null !== $enumType && null !== $value) {
+            $enumFrom = static function ($value) use ($type) {
+                if (!\is_string($value) && !\is_int($value)) {
+                    return null;
+                }
+
+                try {
+                    return $type::from($value);
+                } catch (\ValueError) {
+                    return null;
+                }
+            };
+
+            $value = \is_array($value) ? array_map($enumFrom, $value) : $enumFrom($value);
+        }
+
+        if (null === $value && !($attribute->flags & \FILTER_NULL_ON_FAILURE)) {
+            throw new NotFoundHttpException(sprintf('Invalid query parameter "%s".', $name));
+        }
+
+        if (!\is_array($value)) {
+            return [$value];
+        }
+
+        $filtered = array_filter($value, static fn ($v) => null !== $v);
+
+        if ($argument->isVariadic()) {
+            $filtered = array_values($filtered);
+        }
+
+        if ($filtered !== $value && !($attribute->flags & \FILTER_NULL_ON_FAILURE)) {
+            throw new NotFoundHttpException(sprintf('Invalid query parameter "%s".', $name));
+        }
+
+        return $argument->isVariadic() ? $filtered : [$filtered];
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/RequestAttributeValueResolver.php

@@ -0,0 +1,40 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Yields a non-variadic argument's value from the request attributes.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+final class RequestAttributeValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        return !$argument->isVariadic() && $request->attributes->has($argument->getName());
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        return !$argument->isVariadic() && $request->attributes->has($argument->getName()) ? [$request->attributes->get($argument->getName())] : [];
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/RequestPayloadValueResolver.php

@@ -0,0 +1,201 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Attribute\MapQueryString;
+use Symfony\Component\HttpKernel\Attribute\MapRequestPayload;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
+use Symfony\Component\HttpKernel\Exception\HttpException;
+use Symfony\Component\HttpKernel\KernelEvents;
+use Symfony\Component\Serializer\Exception\NotEncodableValueException;
+use Symfony\Component\Serializer\Exception\PartialDenormalizationException;
+use Symfony\Component\Serializer\Exception\UnsupportedFormatException;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationList;
+use Symfony\Component\Validator\Exception\ValidationFailedException;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+/**
+ * @author Konstantin Myakshin <molodchick@gmail.com>
+ *
+ * @final
+ */
+class RequestPayloadValueResolver implements ValueResolverInterface, EventSubscriberInterface
+{
+    /**
+     * @see \Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer::DISABLE_TYPE_ENFORCEMENT
+     * @see DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS
+     */
+    private const CONTEXT_DENORMALIZE = [
+        'disable_type_enforcement' => true,
+        'collect_denormalization_errors' => true,
+    ];
+
+    /**
+     * @see DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS
+     */
+    private const CONTEXT_DESERIALIZE = [
+        'collect_denormalization_errors' => true,
+    ];
+
+    public function __construct(
+        private readonly SerializerInterface&DenormalizerInterface $serializer,
+        private readonly ?ValidatorInterface $validator = null,
+        private readonly ?TranslatorInterface $translator = null,
+    ) {
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): iterable
+    {
+        $attribute = $argument->getAttributesOfType(MapQueryString::class, ArgumentMetadata::IS_INSTANCEOF)[0]
+            ?? $argument->getAttributesOfType(MapRequestPayload::class, ArgumentMetadata::IS_INSTANCEOF)[0]
+            ?? null;
+
+        if (!$attribute) {
+            return [];
+        }
+
+        if ($argument->isVariadic()) {
+            throw new \LogicException(sprintf('Mapping variadic argument "$%s" is not supported.', $argument->getName()));
+        }
+
+        $attribute->metadata = $argument;
+
+        return [$attribute];
+    }
+
+    public function onKernelControllerArguments(ControllerArgumentsEvent $event): void
+    {
+        $arguments = $event->getArguments();
+
+        foreach ($arguments as $i => $argument) {
+            if ($argument instanceof MapQueryString) {
+                $payloadMapper = 'mapQueryString';
+                $validationFailedCode = $argument->validationFailedStatusCode;
+            } elseif ($argument instanceof MapRequestPayload) {
+                $payloadMapper = 'mapRequestPayload';
+                $validationFailedCode = $argument->validationFailedStatusCode;
+            } else {
+                continue;
+            }
+            $request = $event->getRequest();
+
+            if (!$type = $argument->metadata->getType()) {
+                throw new \LogicException(sprintf('Could not resolve the "$%s" controller argument: argument should be typed.', $argument->metadata->getName()));
+            }
+
+            if ($this->validator) {
+                $violations = new ConstraintViolationList();
+                try {
+                    $payload = $this->$payloadMapper($request, $type, $argument);
+                } catch (PartialDenormalizationException $e) {
+                    $trans = $this->translator ? $this->translator->trans(...) : fn ($m, $p) => strtr($m, $p);
+                    foreach ($e->getErrors() as $error) {
+                        $parameters = [];
+                        $template = 'This value was of an unexpected type.';
+                        if ($expectedTypes = $error->getExpectedTypes()) {
+                            $template = 'This value should be of type {{ type }}.';
+                            $parameters['{{ type }}'] = implode('|', $expectedTypes);
+                        }
+                        if ($error->canUseMessageForUser()) {
+                            $parameters['hint'] = $error->getMessage();
+                        }
+                        $message = $trans($template, $parameters, 'validators');
+                        $violations->add(new ConstraintViolation($message, $template, $parameters, null, $error->getPath(), null));
+                    }
+                    $payload = $e->getData();
+                }
+
+                if (null !== $payload && !\count($violations)) {
+                    $violations->addAll($this->validator->validate($payload, null, $argument->validationGroups ?? null));
+                }
+
+                if (\count($violations)) {
+                    throw new HttpException($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), iterator_to_array($violations))), new ValidationFailedException($payload, $violations));
+                }
+            } else {
+                try {
+                    $payload = $this->$payloadMapper($request, $type, $argument);
+                } catch (PartialDenormalizationException $e) {
+                    throw new HttpException($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), $e->getErrors())), $e);
+                }
+            }
+
+            if (null === $payload) {
+                $payload = match (true) {
+                    $argument->metadata->hasDefaultValue() => $argument->metadata->getDefaultValue(),
+                    $argument->metadata->isNullable() => null,
+                    default => throw new HttpException($validationFailedCode)
+                };
+            }
+
+            $arguments[$i] = $payload;
+        }
+
+        $event->setArguments($arguments);
+    }
+
+    public static function getSubscribedEvents(): array
+    {
+        return [
+            KernelEvents::CONTROLLER_ARGUMENTS => 'onKernelControllerArguments',
+        ];
+    }
+
+    private function mapQueryString(Request $request, string $type, MapQueryString $attribute): ?object
+    {
+        if (!$data = $request->query->all()) {
+            return null;
+        }
+
+        return $this->serializer->denormalize($data, $type, null, $attribute->serializationContext + self::CONTEXT_DENORMALIZE);
+    }
+
+    private function mapRequestPayload(Request $request, string $type, MapRequestPayload $attribute): ?object
+    {
+        if (null === $format = $request->getContentTypeFormat()) {
+            throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, 'Unsupported format.');
+        }
+
+        if ($attribute->acceptFormat && !\in_array($format, (array) $attribute->acceptFormat, true)) {
+            throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, sprintf('Unsupported format, expects "%s", but "%s" given.', implode('", "', (array) $attribute->acceptFormat), $format));
+        }
+
+        if ($data = $request->request->all()) {
+            return $this->serializer->denormalize($data, $type, null, $attribute->serializationContext + self::CONTEXT_DENORMALIZE);
+        }
+
+        if ('' === $data = $request->getContent()) {
+            return null;
+        }
+
+        if ('form' === $format) {
+            throw new HttpException(Response::HTTP_BAD_REQUEST, 'Request payload contains invalid "form" data.');
+        }
+
+        try {
+            return $this->serializer->deserialize($data, $type, $format, self::CONTEXT_DESERIALIZE + $attribute->serializationContext);
+        } catch (UnsupportedFormatException $e) {
+            throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, sprintf('Unsupported format: "%s".', $format), $e);
+        } catch (NotEncodableValueException $e) {
+            throw new HttpException(Response::HTTP_BAD_REQUEST, sprintf('Request payload contains invalid "%s" data.', $format), $e);
+        }
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/RequestValueResolver.php

@@ -0,0 +1,40 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Yields the same instance as the request object passed along.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+final class RequestValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        return Request::class === $argument->getType() || is_subclass_of($argument->getType(), Request::class);
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        return Request::class === $argument->getType() || is_subclass_of($argument->getType(), Request::class) ? [$request] : [];
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/ServiceValueResolver.php

@@ -0,0 +1,99 @@
+<?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\Controller\ArgumentResolver;
+
+use Psr\Container\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Yields a service keyed by _controller and argument name.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class ServiceValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    private ContainerInterface $container;
+
+    public function __construct(ContainerInterface $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        $controller = $request->attributes->get('_controller');
+
+        if (\is_array($controller) && \is_callable($controller, true) && \is_string($controller[0])) {
+            $controller = $controller[0].'::'.$controller[1];
+        } elseif (!\is_string($controller) || '' === $controller) {
+            return false;
+        }
+
+        if ('\\' === $controller[0]) {
+            $controller = ltrim($controller, '\\');
+        }
+
+        if (!$this->container->has($controller) && false !== $i = strrpos($controller, ':')) {
+            $controller = substr($controller, 0, $i).strtolower(substr($controller, $i));
+        }
+
+        return $this->container->has($controller) && $this->container->get($controller)->has($argument->getName());
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        $controller = $request->attributes->get('_controller');
+
+        if (\is_array($controller) && \is_callable($controller, true) && \is_string($controller[0])) {
+            $controller = $controller[0].'::'.$controller[1];
+        } elseif (!\is_string($controller) || '' === $controller) {
+            return [];
+        }
+
+        if ('\\' === $controller[0]) {
+            $controller = ltrim($controller, '\\');
+        }
+
+        if (!$this->container->has($controller) && false !== $i = strrpos($controller, ':')) {
+            $controller = substr($controller, 0, $i).strtolower(substr($controller, $i));
+        }
+
+        if (!$this->container->has($controller) || !$this->container->get($controller)->has($argument->getName())) {
+            return [];
+        }
+
+        try {
+            return [$this->container->get($controller)->get($argument->getName())];
+        } catch (RuntimeException $e) {
+            $what = sprintf('argument $%s of "%s()"', $argument->getName(), $controller);
+            $message = preg_replace('/service "\.service_locator\.[^"]++"/', $what, $e->getMessage());
+
+            if ($e->getMessage() === $message) {
+                $message = sprintf('Cannot resolve %s: %s', $what, $message);
+            }
+
+            $r = new \ReflectionProperty($e, 'message');
+            $r->setValue($e, $message);
+
+            throw $e;
+        }
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/SessionValueResolver.php

@@ -0,0 +1,59 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Yields the Session.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+final class SessionValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        if (!$request->hasSession()) {
+            return false;
+        }
+
+        $type = $argument->getType();
+        if (SessionInterface::class !== $type && !is_subclass_of($type, SessionInterface::class)) {
+            return false;
+        }
+
+        return $request->getSession() instanceof $type;
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        if (!$request->hasSession()) {
+            return [];
+        }
+
+        $type = $argument->getType();
+        if (SessionInterface::class !== $type && !is_subclass_of($type, SessionInterface::class)) {
+            return [];
+        }
+
+        return $request->getSession() instanceof $type ? [$request->getSession()] : [];
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/TraceableValueResolver.php

@@ -0,0 +1,64 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+use Symfony\Component\Stopwatch\Stopwatch;
+
+/**
+ * Provides timing information via the stopwatch.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+final class TraceableValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    private ArgumentValueResolverInterface|ValueResolverInterface $inner;
+    private Stopwatch $stopwatch;
+
+    public function __construct(ArgumentValueResolverInterface|ValueResolverInterface $inner, Stopwatch $stopwatch)
+    {
+        $this->inner = $inner;
+        $this->stopwatch = $stopwatch;
+    }
+
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        if ($this->inner instanceof ValueResolverInterface) {
+            return true;
+        }
+
+        $method = $this->inner::class.'::'.__FUNCTION__;
+        $this->stopwatch->start($method, 'controller.argument_value_resolver');
+
+        $return = $this->inner->supports($request, $argument);
+
+        $this->stopwatch->stop($method);
+
+        return $return;
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): iterable
+    {
+        $method = $this->inner::class.'::'.__FUNCTION__;
+        $this->stopwatch->start($method, 'controller.argument_value_resolver');
+
+        yield from $this->inner->resolve($request, $argument);
+
+        $this->stopwatch->stop($method);
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/UidValueResolver.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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\Uid\AbstractUid;
+
+final class UidValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        return !$argument->isVariadic()
+            && \is_string($request->attributes->get($argument->getName()))
+            && null !== $argument->getType()
+            && is_subclass_of($argument->getType(), AbstractUid::class, true);
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        if ($argument->isVariadic()
+            || !\is_string($value = $request->attributes->get($argument->getName()))
+            || null === ($uidClass = $argument->getType())
+            || !is_subclass_of($uidClass, AbstractUid::class, true)
+        ) {
+            return [];
+        }
+
+        try {
+            return [$uidClass::fromString($value)];
+        } catch (\InvalidArgumentException $e) {
+            throw new NotFoundHttpException(sprintf('The uid for the "%s" parameter is invalid.', $argument->getName()), $e);
+        }
+    }
+}

vendor/symfony/http-kernel/Controller/ArgumentResolver/VariadicValueResolver.php

@@ -0,0 +1,50 @@
+<?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\Controller\ArgumentResolver;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Yields a variadic argument's values from the request attributes.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ */
+final class VariadicValueResolver implements ArgumentValueResolverInterface, ValueResolverInterface
+{
+    /**
+     * @deprecated since Symfony 6.2, use resolve() instead
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        @trigger_deprecation('symfony/http-kernel', '6.2', 'The "%s()" method is deprecated, use "resolve()" instead.', __METHOD__);
+
+        return $argument->isVariadic() && $request->attributes->has($argument->getName());
+    }
+
+    public function resolve(Request $request, ArgumentMetadata $argument): array
+    {
+        if (!$argument->isVariadic() || !$request->attributes->has($argument->getName())) {
+            return [];
+        }
+
+        $values = $request->attributes->get($argument->getName());
+
+        if (!\is_array($values)) {
+            throw new \InvalidArgumentException(sprintf('The action argument "...$%1$s" is required to be an array, the request attribute "%1$s" contains a type of "%2$s" instead.', $argument->getName(), get_debug_type($values)));
+        }
+
+        return $values;
+    }
+}