Upgrade framework

vendor/symfony/http-kernel/ControllerMetadata/ArgumentMetadataFactory.php

@@ -18,112 +18,59 @@ namespace Symfony\Component\HttpKernel\ControllerMetadata;
  */
 final class ArgumentMetadataFactory implements ArgumentMetadataFactoryInterface
 {
-    /**
-     * If the ...$arg functionality is available.
-     *
-     * Requires at least PHP 5.6.0 or HHVM 3.9.1
-     *
-     * @var bool
-     */
-    private $supportsVariadic;
-
-    /**
-     * If the reflection supports the getType() method to resolve types.
-     *
-     * Requires at least PHP 7.0.0 or HHVM 3.11.0
-     *
-     * @var bool
-     */
-    private $supportsParameterType;
-
-    public function __construct()
-    {
-        $this->supportsVariadic = method_exists('ReflectionParameter', 'isVariadic');
-        $this->supportsParameterType = method_exists('ReflectionParameter', 'getType');
-    }
-
     /**
      * {@inheritdoc}
      */
-    public function createArgumentMetadata($controller)
+    public function createArgumentMetadata(string|object|array $controller): array
     {
-        $arguments = array();
+        $arguments = [];
 
-        if (is_array($controller)) {
+        if (\is_array($controller)) {
             $reflection = new \ReflectionMethod($controller[0], $controller[1]);
-        } elseif (is_object($controller) && !$controller instanceof \Closure) {
-            $reflection = (new \ReflectionObject($controller))->getMethod('__invoke');
+            $class = $reflection->class;
+        } elseif (\is_object($controller) && !$controller instanceof \Closure) {
+            $reflection = new \ReflectionMethod($controller, '__invoke');
+            $class = $reflection->class;
         } else {
             $reflection = new \ReflectionFunction($controller);
+            if ($class = str_contains($reflection->name, '{closure}') ? null : (\PHP_VERSION_ID >= 80111 ? $reflection->getClosureCalledClass() : $reflection->getClosureScopeClass())) {
+                $class = $class->name;
+            }
         }
 
         foreach ($reflection->getParameters() as $param) {
-            $arguments[] = new ArgumentMetadata($param->getName(), $this->getType($param), $this->isVariadic($param), $this->hasDefaultValue($param), $this->getDefaultValue($param), $param->allowsNull());
+            $attributes = [];
+            foreach ($param->getAttributes() as $reflectionAttribute) {
+                if (class_exists($reflectionAttribute->getName())) {
+                    $attributes[] = $reflectionAttribute->newInstance();
+                }
+            }
+
+            $arguments[] = new ArgumentMetadata($param->getName(), $this->getType($param, $class), $param->isVariadic(), $param->isDefaultValueAvailable(), $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null, $param->allowsNull(), $attributes);
         }
 
         return $arguments;
     }
 
-    /**
-     * Returns whether an argument is variadic.
-     *
-     * @param \ReflectionParameter $parameter
-     *
-     * @return bool
-     */
-    private function isVariadic(\ReflectionParameter $parameter)
-    {
-        return $this->supportsVariadic && $parameter->isVariadic();
-    }
-
-    /**
-     * Determines whether an argument has a default value.
-     *
-     * @param \ReflectionParameter $parameter
-     *
-     * @return bool
-     */
-    private function hasDefaultValue(\ReflectionParameter $parameter)
-    {
-        return $parameter->isDefaultValueAvailable();
-    }
-
-    /**
-     * Returns a default value if available.
-     *
-     * @param \ReflectionParameter $parameter
-     *
-     * @return mixed|null
-     */
-    private function getDefaultValue(\ReflectionParameter $parameter)
-    {
-        return $this->hasDefaultValue($parameter) ? $parameter->getDefaultValue() : null;
-    }
-
     /**
      * Returns an associated type to the given parameter if available.
-     *
-     * @param \ReflectionParameter $parameter
-     *
-     * @return null|string
      */
-    private function getType(\ReflectionParameter $parameter)
+    private function getType(\ReflectionParameter $parameter, ?string $class): ?string
     {
-        if ($this->supportsParameterType) {
-            if (!$type = $parameter->getType()) {
-                return;
-            }
-            $typeName = $type instanceof \ReflectionNamedType ? $type->getName() : $type->__toString();
-            if ('array' === $typeName && !$type->isBuiltin()) {
-                // Special case for HHVM with variadics
-                return;
-            }
+        if (!$type = $parameter->getType()) {
+            return null;
+        }
+        $name = $type instanceof \ReflectionNamedType ? $type->getName() : (string) $type;
 
-            return $typeName;
+        if (null !== $class) {
+            switch (strtolower($name)) {
+                case 'self':
+                    return $class;
+                case 'parent':
+                    return get_parent_class($class) ?: null;
+            }
         }
 
-        if (preg_match('/^(?:[^ ]++ ){4}([a-zA-Z_\x7F-\xFF][^ ]++)/', $parameter, $info)) {
-            return $info[1];
-        }
+        return $name;
     }
 }