Merge branch '7.4' into 8.0

* 7.4:
  [TypeInfo] Simple array should be array type
  Handle signals on text input
  [TwigBridge] Fix form constraint
  [Runtime] Reuse the already created Request object when the app needs it as argument returns a kernel
  [Config] Fix array shape generation for backed enums
  [Config] Define `TreeBuilder` default generic type
  Update validators.el.xlf
  Fix MoneyType: add missing step attribute when html5=true
  [JsonStreamer] fix invalid json output for list of self
  [Console] Preserve `--help` option when a command is not found
  [FrameworkBundle] Fix using `FailedMessages*Command` with `SigningSerializer`
  [Lock] Fix unserializing already serialized Key payloads
  [HttpClient] CachingHttpClient must run after UriTemplate and Scoping
  Only register PhpConfigReferenceDumpPass in dev env with debug flag enabled
  [Messenger] Fix PHP 8.5 deprecation for pgsqlGetNotify() in PostgreSQL transport
  chore: PHP CS Fixer - do not use deprecated sets in config
  verify spanish translations with state needs-review-translation
  [Security] Fix OIDC discovery when using multiple HttpClient instances
  [DependencyInjection] Allow manual bindings on parameters with #[Target]

Author: nicolas-grekas

Tests/TypeResolver/StringTypeResolverTest.php

@@ -70,7 +70,16 @@ public static function resolveDataProvider(): iterable
         yield [Type::callable(), 'callable(string, int): mixed'];
 
         // array
-        yield [Type::list(Type::bool()), 'bool[]'];
+        yield [Type::array(Type::bool()), 'bool[]'];
+        yield [Type::array(Type::bool()), 'array<bool>'];
+        yield [Type::array(Type::bool(), Type::int()), 'array<int, bool>'];
+        yield [Type::array(Type::bool(), Type::arrayKey()), 'array<array-key, bool>'];
+        yield [Type::array(Type::bool(), Type::arrayKey()), 'array<int|string, bool>'];
+        yield [Type::array(Type::bool(), Type::arrayKey()), 'non-empty-array<int|string, bool>'];
+
+        // list
+        yield [Type::list(Type::bool()), 'list<bool>'];
+        yield [Type::list(Type::bool()), 'non-empty-list<bool>'];
 
         // array shape
         yield [Type::arrayShape(['foo' => Type::true(), 1 => Type::false()]), 'array{foo: true, 1: false}'];
@@ -257,4 +266,28 @@ public function testCannotResolveValueOfInvalidType()
         $this->expectException(UnsupportedException::class);
         $this->resolver->resolve('value-of<int>');
     }
+
+    public function testCannotResolveListWithKeyType()
+    {
+        $this->expectException(UnsupportedException::class);
+        $this->resolver->resolve('list<int, string>');
+    }
+
+    public function testCannotResolveInvalidNonEmptyListWithKeyType()
+    {
+        $this->expectException(UnsupportedException::class);
+        $this->resolver->resolve('non-empty-list<int, string>');
+    }
+
+    public function testCannotResolveInvalidArrayKeyType()
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->resolver->resolve('array<mixed, string>');
+    }
+
+    public function testCannotResolveInvalidUnionArrayKeyType()
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->resolver->resolve('array<int|mixed, string>');
+    }
 }

Type/CollectionType.php

@@ -48,6 +48,16 @@ public function __construct(
             if (!$keyType instanceof BuiltinType || TypeIdentifier::INT !== $keyType->getTypeIdentifier()) {
                 throw new InvalidArgumentException(\sprintf('"%s" is not a valid list key type.', (string) $keyType));
             }
+        } elseif ($type instanceof GenericType && $type->getWrappedType() instanceof BuiltinType && TypeIdentifier::ARRAY === $type->getWrappedType()->getTypeIdentifier()) {
+            $keyType = $this->getCollectionKeyType();
+
+            $keyTypes = $keyType instanceof UnionType ? $keyType->getTypes() : [$keyType];
+
+            foreach ($keyTypes as $type) {
+                if (!$type instanceof BuiltinType || !\in_array($type->getTypeIdentifier(), [TypeIdentifier::INT, TypeIdentifier::STRING], true)) {
+                    throw new InvalidArgumentException(\sprintf('"%s" is not a valid array key type.', (string) $keyType));
+                }
+            }
         }
     }
 

TypeResolver/StringTypeResolver.php

@@ -106,7 +106,7 @@ private function getTypeFromNode(TypeNode $node, ?TypeContext $typeContext): Typ
         }
 
         if ($node instanceof ArrayTypeNode) {
-            return Type::list($this->getTypeFromNode($node->type, $typeContext));
+            return Type::array($this->getTypeFromNode($node->type, $typeContext));
         }
 
         if ($node instanceof ArrayShapeNode) {
@@ -269,6 +269,10 @@ private function getTypeFromNode(TypeNode $node, ?TypeContext $typeContext): Typ
                 if (1 === \count($variableTypes)) {
                     return new CollectionType(Type::generic($type, $keyType, $variableTypes[0]), $asList);
                 } elseif (2 === \count($variableTypes)) {
+                    if ($asList) {
+                        throw new \DomainException(\sprintf('"%s" type cannot have a key type defined.', $node->type));
+                    }
+
                     return Type::collection($type, $variableTypes[1], $variableTypes[0], $asList);
                 }
             }