Fixup

Author: danog

tests/Unit/Type/Parser/LexingParserTest.php

@@ -1609,6 +1609,14 @@ public function test_shaped_list_missing_shorthand_splat_closing_bracket_throws_
         self::assertSame('Missing closing curly bracket in shaped list signature `list{string, ...list<float>`.', $type->message());
     }
 
+    public function test_shaped_list_missing_closing_bracket_after_shorthand_splat_type_throws_exception(): void
+    {
+        $type = $this->parse('list{string, ...<float>');
+
+        self::assertInstanceOf(UnresolvableType::class, $type);
+        self::assertSame('Missing closing curly bracket in shaped list signature `list{string, ...list<float>`.', $type->message());
+    }
+
     public function test_shaped_list_invalid_shorthand_splat_closing_bracket_throws_exception(): void
     {
         $type = $this->parse('list{string, ...<float int}');
@@ -1657,6 +1665,14 @@ public function test_shaped_list_typed_splat_with_unexpected_token_throws_except
         self::assertSame('Unexpected `int` after sealed type in shaped array signature `array{0: string, ...floatint`, expected a `}`.', $type->message());
     }
 
+    public function test_shaped_list_typed_splat_with_nested_list_missing_closing_bracket_throws_exception(): void
+    {
+        $type = $this->parse('list{string, ...list<float>');
+
+        self::assertInstanceOf(UnresolvableType::class, $type);
+        self::assertSame('Missing closing curly bracket in shaped list signature `list{string, list<float>`.', $type->message());
+    }
+
     public function test_shaped_list_missing_element_type_throws_exception(): void
     {
         $type = $this->parse('list{0:');
@@ -1737,6 +1753,22 @@ public function test_shaped_array_with_duplicate_shorthand_splat_throws_exceptio
         self::assertSame('A shaped array can only have one splat element in `array{0: int, ..., ...}`.', $type->message());
     }
 
+    public function test_shaped_array_shorthand_splat_with_invalid_key_type_throws_exception(): void
+    {
+        $type = $this->parse('array{0: int, ...<float, string>}');
+
+        self::assertInstanceOf(UnresolvableType::class, $type);
+        self::assertSame('Invalid type `array<float, string>`: invalid array-key element(s) `float`, each element must be an integer or a string.', $type->message());
+    }
+
+    public function test_shaped_array_shorthand_splat_missing_final_closing_bracket_throws_exception(): void
+    {
+        $type = $this->parse('array{0: int, ...<string, float>');
+
+        self::assertInstanceOf(UnresolvableType::class, $type);
+        self::assertSame('Missing closing curly bracket in shaped array signature `array{0: int, ...array<string, float>`.', $type->message());
+    }
+
     public function test_shaped_array_shorthand_splat_with_unexpected_token_after_comma_throws_exception(): void
     {
         $type = $this->parse('array{0: int, ...<int>, string}');
@@ -1745,6 +1777,14 @@ public function test_shaped_array_shorthand_splat_with_unexpected_token_after_co
         self::assertSame('Unexpected `,string` after sealed type in shaped array signature `array{0: int, ...array<int>,string`, expected a `}`.', $type->message());
     }
 
+    public function test_shaped_list_with_trailing_comma_can_be_followed_by_union(): void
+    {
+        $type = $this->parse('list{string,}|null');
+
+        self::assertInstanceOf(UnionType::class, $type);
+        self::assertSame('list{string}|null', $type->toString());
+    }
+
     public function test_invalid_iterable_key_throws_exception(): void
     {
         $type = $this->parse('iterable<float, string>');

tests/Unit/Type/Types/ShapedListTypeTest.php

@@ -433,6 +433,54 @@ public function test_does_not_infer_generics_from_non_shaped_list_type(): void
         self::assertSame([], $generics->items);
     }
 
+    public function test_infers_generics_from_matching_shaped_list_elements(): void
+    {
+        $type = ShapedListType::from(
+            elements: [
+                new ShapedArrayElement(new IntegerValueType(0), new GenericType('T', new NativeStringType())),
+                new ShapedArrayElement(new IntegerValueType(1), new GenericType('U', new NativeIntegerType())),
+            ],
+            isUnsealed: false,
+        );
+
+        $other = ShapedListType::from(
+            elements: [
+                new ShapedArrayElement(new IntegerValueType(0), new NativeStringType()),
+                new ShapedArrayElement(new IntegerValueType(1), new NativeIntegerType()),
+            ],
+            isUnsealed: false,
+        );
+
+        $generics = $type->inferGenericsFrom($other, new Generics());
+
+        self::assertSame(['T', 'U'], array_keys($generics->items));
+        self::assertSame('string', $generics->items['T']->toString());
+        self::assertSame('int', $generics->items['U']->toString());
+    }
+
+    public function test_infer_generics_skips_missing_keys_and_keeps_later_matches(): void
+    {
+        $type = ShapedListType::from(
+            elements: [
+                new ShapedArrayElement(new IntegerValueType(0), new GenericType('T', new NativeStringType())),
+                new ShapedArrayElement(new IntegerValueType(1), new GenericType('U', new NativeIntegerType())),
+            ],
+            isUnsealed: false,
+        );
+
+        $other = new ShapedListType(
+            elements: [
+                1 => new ShapedArrayElement(new IntegerValueType(1), new NativeIntegerType()),
+            ],
+            isUnsealed: false,
+        );
+
+        $generics = $type->inferGenericsFrom($other, new Generics());
+
+        self::assertSame(['U'], array_keys($generics->items));
+        self::assertSame('int', $generics->items['U']->toString());
+    }
+
     public function test_native_type_is_list(): void
     {
         self::assertSame('list', $this->type->nativeType()->toString());