Add tests for sealed and unsealed array shapes; improve type error handling

Author: rcalicdan

tests/TypeChecking/ArraysAndShapes/ArrayAndListTypesTest.php

@@ -116,6 +116,27 @@ function testKeylessImplicitTupleShape(array $tuple): bool
     return true;
 }
 
+/**
+ * 1. Sealed Shape (Default)
+ *
+ * @param array{id: positive-int, username: non-empty-string} $sealedPayload
+ */
+function testSealedShape(array $sealedPayload): bool
+{
+    return true;
+}
+
+/**
+ * 2. Unsealed Typed Shape
+ * Requires 'id' to be positive-int, but permits additional string-string pairs
+ *
+ * @param array{id: positive-int, ...<string, string>} $unsealedPayload
+ */
+function testUnsealedTypedShape(array $unsealedPayload): bool
+{
+    return true;
+}
+
 /**
  * Helpers for Issue #20 Edge Cases
  *
@@ -161,9 +182,8 @@ function testReturnKeylessTuple(bool $valid): array
     });
 
     test('throws TypeError when array contains an invalid class object', function () {
-        expect(fn () => testDogArrayParam([new Dog(), new Car()]))
-            ->toThrow(TypeError::class)
-        ;
+        expect(fn() => testDogArrayParam([new Dog(), new Car()]))
+            ->toThrow(TypeError::class);
     });
 });
 
@@ -174,16 +194,14 @@ function testReturnKeylessTuple(bool $valid): array
 
     test('throws TypeError when key type is invalid', function () {
         // Integer key 0 instead of string key
-        expect(fn () => testAssocScoreArrayParam([0 => 100]))
-            ->toThrow(TypeError::class, 'key')
-        ;
+        expect(fn() => testAssocScoreArrayParam([0 => 100]))
+            ->toThrow(TypeError::class, 'key');
     });
 
     test('throws TypeError when value type is invalid', function () {
         // Negative integer -10 instead of positive-int
-        expect(fn () => testAssocScoreArrayParam(['alice' => -10]))
-            ->toThrow(TypeError::class, "['alice']")
-        ;
+        expect(fn() => testAssocScoreArrayParam(['alice' => -10]))
+            ->toThrow(TypeError::class, "['alice']");
     });
 });
 
@@ -193,23 +211,20 @@ function testReturnKeylessTuple(bool $valid): array
     });
 
     test('throws TypeError when list contains associative keys', function () {
-        expect(fn () => testTagListParam(['tag' => 'php']))
-            ->toThrow(TypeError::class, 'must be a list')
-        ;
+        expect(fn() => testTagListParam(['tag' => 'php']))
+            ->toThrow(TypeError::class, 'must be a list');
     });
 
     test('throws TypeError when list contains an empty string', function () {
-        expect(fn () => testTagListParam(['php', '']))
-            ->toThrow(TypeError::class, 'non-empty-string')
-        ;
+        expect(fn() => testTagListParam(['php', '']))
+            ->toThrow(TypeError::class, 'non-empty-string');
     });
 
     test('accepts valid non-empty list and rejects empty array', function () {
         expect(testNonEmptyNumberListParam([1, 2, 3]))->toBe(3);
 
-        expect(fn () => testNonEmptyNumberListParam([]))
-            ->toThrow(TypeError::class, 'non-empty list')
-        ;
+        expect(fn() => testNonEmptyNumberListParam([]))
+            ->toThrow(TypeError::class, 'non-empty list');
     });
 });
 
@@ -228,19 +243,17 @@ function testReturnKeylessTuple(bool $valid): array
             'math' => [100, -50], // -50 is not positive-int
         ];
 
-        expect(fn () => testNestedMatrixParam($invalidMatrix))
-            ->toThrow(TypeError::class)
-        ;
+        expect(fn() => testNestedMatrixParam($invalidMatrix))
+            ->toThrow(TypeError::class);
     });
 
     test('throws TypeError when nested list is associative', function () {
         $invalidMatrix = [
             'math' => ['score' => 100], // Not a list
         ];
 
-        expect(fn () => testNestedMatrixParam($invalidMatrix))
-            ->toThrow(TypeError::class)
-        ;
+        expect(fn() => testNestedMatrixParam($invalidMatrix))
+            ->toThrow(TypeError::class);
     });
 });
 
@@ -260,9 +273,8 @@ function testReturnKeylessTuple(bool $valid): array
             new Producer(new Car()), // Car is not an Animal
         ];
 
-        expect(fn () => testGenericProducerListParam($producers))
-            ->toThrow(TypeError::class)
-        ;
+        expect(fn() => testGenericProducerListParam($producers))
+            ->toThrow(TypeError::class);
     });
 });
 
@@ -273,14 +285,12 @@ function testReturnKeylessTuple(bool $valid): array
 
     test('throws TypeError on invalid tuple element', function () {
         // First item -5 is not positive-int
-        expect(fn () => testTupleShapeParam([-5, 'alice']))
-            ->toThrow(TypeError::class, "['0']")
-        ;
+        expect(fn() => testTupleShapeParam([-5, 'alice']))
+            ->toThrow(TypeError::class, "['0']");
 
         // Second item '' is not non-empty-string
-        expect(fn () => testTupleShapeParam([10, '']))
-            ->toThrow(TypeError::class, "['1']")
-        ;
+        expect(fn() => testTupleShapeParam([10, '']))
+            ->toThrow(TypeError::class, "['1']");
     });
 });
 
@@ -301,9 +311,8 @@ function testReturnKeylessTuple(bool $valid): array
             'invalid_extra' => 999, // int given, but string expected by unsealed type
         ];
 
-        expect(fn () => testUnsealedShapeParam($payload))
-            ->toThrow(TypeError::class)
-        ;
+        expect(fn() => testUnsealedShapeParam($payload))
+            ->toThrow(TypeError::class);
     });
 });
 
@@ -316,7 +325,7 @@ function testReturnKeylessTuple(bool $valid): array
     });
 
     test('throws TypeError when any variadic argument violates the array shape', function () {
-        expect(fn () => testVariadicArrayShapeParam(
+        expect(fn() => testVariadicArrayShapeParam(
             ['id' => 1, 'name' => 'Alice'],
             ['id' => -2, 'name' => 'Bob'] // -2 is not positive-int
         ))->toThrow(TypeError::class);
@@ -340,9 +349,8 @@ function testReturnKeylessTuple(bool $valid): array
             'tags' => ['php', ''], // Empty string violates list<non-empty-string>
         ];
 
-        expect(fn () => testComplexNestedShapeParam($payload))
-            ->toThrow(TypeError::class)
-        ;
+        expect(fn() => testComplexNestedShapeParam($payload))
+            ->toThrow(TypeError::class);
     });
 });
 
@@ -353,12 +361,12 @@ function testReturnKeylessTuple(bool $valid): array
             ['status_ok', 'code' => 200, [1, 2, 3]]
         ))->toBeTrue();
 
-        expect(fn () => testLocalTupleAliasParam(
+        expect(fn() => testLocalTupleAliasParam(
             [[10, -5], ['a', 'b']],
             ['status_ok', 'code' => 200, [1, 2, 3]]
         ))->toThrow(TypeError::class, "Argument \$payload['0'][1] must be of type positive-int");
 
-        expect(fn () => testLocalTupleAliasParam(
+        expect(fn() => testLocalTupleAliasParam(
             [[10, 20], ['a', 'b']],
             ['status_ok', 'code' => -100, [1, 2, 3]]
         ))->toThrow(TypeError::class, "Argument \$mixedPayload['code'] must be of type positive-int");
@@ -367,16 +375,49 @@ function testReturnKeylessTuple(bool $valid): array
     test('resolves keyless tuple shapes imported via @phpstan-import-type', function () {
         expect(testImportedTupleAliasParam([[100, 200], 'valid_string']))->toBeTrue();
 
-        expect(fn () => testImportedTupleAliasParam([[100, 200], '']))
-            ->toThrow(TypeError::class, "Argument \$tuple['1'] must be of type non-empty-string")
-        ;
+        expect(fn() => testImportedTupleAliasParam([[100, 200], '']))
+            ->toThrow(TypeError::class, "Argument \$tuple['1'] must be of type non-empty-string");
     });
 
     test('validates keyless tuple shapes returned from functions', function () {
         expect(testReturnKeylessTuple(true))->toBe([[10, 20], 'bundle']);
 
-        expect(fn () => testReturnKeylessTuple(false))
-            ->toThrow(TypeError::class, "Return value['0'][1] must be of type positive-int")
-        ;
+        expect(fn() => testReturnKeylessTuple(false))
+            ->toThrow(TypeError::class, "Return value['0'][1] must be of type positive-int");
+    });
+});
+
+describe('Sealed vs Unsealed Array Shapes', function () {
+    describe('Sealed Shapes (array{id: int})', function () {
+        test('accepts exact declared shape keys', function () {
+            expect(testSealedShape(['id' => 10, 'username' => 'Alice']))->toBeTrue();
+        });
+
+        test('throws TypeError when sealed shape receives unexpected extra key', function () {
+            expect(fn() => testSealedShape(['id' => 10, 'username' => 'Alice', 'extra_key' => 'bar']))
+                ->toThrow(TypeError::class, "contains unsealed unexpected key 'extra_key'");
+        });
+    });
+
+    describe('Unsealed Typed Shapes (array{id: int, ...<string, string>})', function () {
+        test('accepts required keys plus additional string-string pairs', function () {
+            $payload = [
+                'id' => 42,
+                'category' => 'admin_user',
+                'department' => 'engineering',
+            ];
+
+            expect(testUnsealedTypedShape($payload))->toBeTrue();
+        });
+
+        test('throws TypeError when unsealed extra value violates unsealed type contract', function () {
+            $payload = [
+                'id' => 42,
+                'code' => 999, // 999 is int, but unsealed type requires string value!
+            ];
+
+            expect(fn() => testUnsealedTypedShape($payload))
+                ->toThrow(TypeError::class, "['code'] must be of type string, int (999) given");
+        });
     });
 });

tests/TypeChecking/InheritanceAndAttributes/ParameterShiftInheritanceTest.php

@@ -43,25 +43,22 @@
         test('throws TypeError when renamed $userId parameter fails parent inherited positive-int contract', function () {
             $service = new ChildShiftedMethodService();
 
-            expect(fn () => $service->updateUser(-5, 'Alice', ['active' => true]))
-                ->toThrow(TypeError::class, 'Argument $userId must be of type positive-int')
-            ;
+            expect(fn() => $service->updateUser(-5, 'Alice', ['active' => true]))
+                ->toThrow(TypeError::class, 'Argument $userId must be of type positive-int');
         });
 
         test('throws TypeError when renamed $userName parameter fails parent inherited non-empty-string contract', function () {
             $service = new ChildShiftedMethodService();
 
-            expect(fn () => $service->updateUser(42, '', ['active' => true]))
-                ->toThrow(TypeError::class, 'Argument $userName must be of type non-empty-string')
-            ;
+            expect(fn() => $service->updateUser(42, '', ['active' => true]))
+                ->toThrow(TypeError::class, 'Argument $userName must be of type non-empty-string');
         });
 
         test('throws TypeError when renamed $userOptions parameter fails parent inherited shape contract', function () {
             $service = new ChildShiftedMethodService();
 
-            expect(fn () => $service->updateUser(42, 'Alice', ['active' => 'not_bool']))
-                ->toThrow(TypeError::class, "Argument \$userOptions['active'] must be of type bool")
-            ;
+            expect(fn() => $service->updateUser(42, 'Alice', ['active' => 'not_bool']))
+                ->toThrow(TypeError::class, "Argument \$userOptions['active'] must be of type bool");
         });
     });
 
@@ -71,15 +68,13 @@
         });
 
         test('throws TypeError when renamed $itemBatch parameter fails parent contract on static method', function () {
-            expect(fn () => ChildShiftedMethodService::processBatch([10, -5], 'json'))
-                ->toThrow(TypeError::class, 'Argument $itemBatch[1] must be of type positive-int')
-            ;
+            expect(fn() => ChildShiftedMethodService::processBatch([10, -5], 'json'))
+                ->toThrow(TypeError::class, 'Argument $itemBatch[1] must be of type positive-int');
         });
 
         test('throws TypeError when renamed $outputFormat parameter fails parent contract on static method', function () {
-            expect(fn () => ChildShiftedMethodService::processBatch([10, 20], ''))
-                ->toThrow(TypeError::class, 'Argument $outputFormat must be of type non-empty-string')
-            ;
+            expect(fn() => ChildShiftedMethodService::processBatch([10, 20], ''))
+                ->toThrow(TypeError::class, 'Argument $outputFormat must be of type non-empty-string');
         });
     });
 
@@ -89,50 +84,58 @@
 
             expect($service->execute(200, 'valid_token'))->toBeTrue();
 
-            expect(fn () => $service->execute(-10, 'valid_token'))
-                ->toThrow(TypeError::class, 'Argument $statusCode must be of type positive-int')
-            ;
+            expect(fn() => $service->execute(-10, 'valid_token'))
+                ->toThrow(TypeError::class, 'Argument $statusCode must be of type positive-int');
 
-            expect(fn () => $service->execute(200, ''))
-                ->toThrow(TypeError::class, 'Argument $authToken must be of type non-empty-string')
-            ;
+            expect(fn() => $service->execute(200, ''))
+                ->toThrow(TypeError::class, 'Argument $authToken must be of type non-empty-string');
         });
 
         test('inherits and validates contracts from Abstract Classes with renamed parameters', function () {
             $service = new ChildShiftedOopService();
 
             expect($service->processItems([10, 20, 30]))->toBeTrue();
 
-            expect(fn () => $service->processItems([10, -5, 30]))
-                ->toThrow(TypeError::class, 'Argument $itemList[1] must be of type positive-int')
-            ;
+            expect(fn() => $service->processItems([10, -5, 30]))
+                ->toThrow(TypeError::class, 'Argument $itemList[1] must be of type positive-int');
         });
 
         test('inherits and validates contracts from Traits with renamed parameters', function () {
             $service = new ChildShiftedOopService();
 
             expect($service->logEvent(1, 'info_message'))->toBeTrue();
 
-            expect(fn () => $service->logEvent(-1, 'info_message'))
-                ->toThrow(TypeError::class, 'Argument $logLevel must be of type positive-int')
-            ;
+            expect(fn() => $service->logEvent(-1, 'info_message'))
+                ->toThrow(TypeError::class, 'Argument $logLevel must be of type positive-int');
 
-            expect(fn () => $service->logEvent(1, ''))
-                ->toThrow(TypeError::class, 'Argument $logMessage must be of type non-empty-string')
-            ;
+            expect(fn() => $service->logEvent(1, ''))
+                ->toThrow(TypeError::class, 'Argument $logMessage must be of type non-empty-string');
         });
 
         test('inherits Interface contracts when method is fulfilled by Trait with renamed parameters', function () {
             $service = new ChildShiftedTraitAppService();
 
             expect($service->runAction(100, 'valid_token'))->toBeTrue();
 
-            expect(fn () => $service->runAction(-5, 'valid_token'))
-                ->toThrow(TypeError::class, 'Argument $actionCode must be of type positive-int')
-            ;
+            expect(fn() => $service->runAction(-5, 'valid_token'))
+                ->toThrow(TypeError::class, 'Argument $actionCode must be of type positive-int');
 
-            expect(fn () => $service->runAction(100, ''))
+            expect(fn() => $service->runAction(100, ''))
                 ->toThrow(TypeError::class, 'Argument $actionToken must be of type non-empty-string');
         });
     });
 });
+
+describe('PHP 8.0+ Named Arguments on Subtype Methods with Renamed Parameters', function () {
+    test('validates named arguments passed in swapped order on subtype method with renamed parameters from Interface', function () {
+        $service = new ChildShiftedOopService();
+
+        expect($service->execute(authToken: 'valid_token', statusCode: 200))->toBeTrue();
+
+        expect(fn() => $service->execute(authToken: 'valid_token', statusCode: -10))
+            ->toThrow(TypeError::class, 'Argument $statusCode must be of type positive-int');
+
+        expect(fn() => $service->execute(authToken: '', statusCode: 200))
+            ->toThrow(TypeError::class, 'Argument $authToken must be of type non-empty-string');
+    });
+});