Preserve possible empty results in generic array merges

Benevolent unions can report definite iteration while still admitting an empty branch. Require an operand to exclude the empty array before marking the generic fallback nonempty.

Cover explicit empty and optional-shape alternatives, required generic operands, and never-alternative normalization.

Author: jbboehr

src/ArrayMergeType.php

@@ -306,6 +306,7 @@ protected function getResult(): Type
         }
 
         if ($nConstantArrays + $nOtherArrays === count($types)) {
+            $emptyArray = ConstantArrayTypeBuilder::createEmpty()->getArray();
             $allIntegerKeys = true;
             $atLeastOneNonEmpty = false;
             $combinedKeyType = null;
@@ -339,7 +340,7 @@ protected function getResult(): Type
                     return new ArrayType(new MixedType(true), new MixedType(true));
                 }
 
-                if ($type->isIterableAtLeastOnce()->yes()) {
+                if ($type->isSuperTypeOf($emptyArray)->no()) {
                     $atLeastOneNonEmpty = true;
                 }
 

tests/ArrayMergeNonEmptyTest.php

@@ -63,6 +63,12 @@ public static function nonEmptyProvider(): iterable
         yield 'nonempty intersection survives integer-key reindexing' => [
             'array-merge<array{2?: 1, 7?: 2}&non-empty-array>',
         ];
+        yield 'nonempty generic operand before a possibly empty operand' => [
+            'array-merge<non-empty-array<string, int>, array<string, int>>',
+        ];
+        yield 'nonempty generic operand after a possibly empty operand' => [
+            'array-merge<array<string, int>, non-empty-array<string, int>>',
+        ];
     }
 
     #[DataProvider('nonEmptyProvider')]
@@ -92,6 +98,9 @@ public static function possiblyEmptyProvider(): iterable
         yield 'possible empty survivor beside an impossible branch' => [
             'array-merge<array{}|array{bad: never}|array{a: 1}>',
         ];
+        yield 'serialized benevolent union with conflicting key orders' => [
+            'array-merge<__array_merge_benevolent<array{}|array{a: 1, b: 2}|array{b: 2, a: 1}>>',
+        ];
     }
 
     #[DataProvider('possiblyEmptyProvider')]
@@ -201,6 +210,57 @@ public function testBenevolentUnionRetainsReachableOptionalShapeAlternative(): v
         $this->assertTrue($result->isIterableAtLeastOnce()->maybe(), $description);
     }
 
+    public function testBenevolentUnionRetainsEmptyThroughKeyOrderFallback(): void
+    {
+        $empty = self::constantArrayFromRuntime([]);
+        $firstOrder = self::constantArrayFromRuntime(['a' => 1, 'b' => 2]);
+        $secondOrder = self::constantArrayFromRuntime(['b' => 2, 'a' => 1]);
+        $operand = new BenevolentUnionType([$empty, $firstOrder, $secondOrder]);
+        $result = (new ArrayMergeType([$operand]))->resolve();
+        $description = $result->describe(VerbosityLevel::precise());
+
+        foreach ([$result, $result->getKeysArray(), $result->getValuesArray()] as $type) {
+            $this->assertTrue($type->isSuperTypeOf($empty)->yes(), $description);
+            $this->assertTrue($type->isIterableAtLeastOnce()->maybe(), $description);
+        }
+
+        $this->assertTrue($result->isSuperTypeOf($firstOrder)->yes(), $description);
+        $this->assertTrue($result->isSuperTypeOf($secondOrder)->yes(), $description);
+    }
+
+    public function testBenevolentUnionRetainsOptionalShapeThroughKeyOrderFallback(): void
+    {
+        $empty = self::constantArrayFromRuntime([]);
+        $operand = new BenevolentUnionType([
+            self::optionalStringShape(),
+            self::constantArrayFromRuntime(['a' => 1, 'b' => 2]),
+            self::constantArrayFromRuntime(['b' => 2, 'a' => 1]),
+        ]);
+        $result = (new ArrayMergeType([$operand]))->resolve();
+        $description = $result->describe(VerbosityLevel::precise());
+
+        foreach ([$result, $result->getKeysArray(), $result->getValuesArray()] as $type) {
+            $this->assertTrue($type->isSuperTypeOf($empty)->yes(), $description);
+            $this->assertTrue($type->isIterableAtLeastOnce()->maybe(), $description);
+        }
+    }
+
+    public function testBenevolentUnionOfNonEmptyGenericArraysRemainsNonEmpty(): void
+    {
+        $resolver = self::getContainer()->getByType(TypeStringResolver::class);
+        $operand = new BenevolentUnionType([
+            $resolver->resolve('non-empty-array<string, int>'),
+            $resolver->resolve('non-empty-array<int, int>'),
+        ]);
+        $result = (new ArrayMergeType([$operand]))->resolve();
+        $description = $result->describe(VerbosityLevel::precise());
+
+        $this->assertTrue($result->isIterableAtLeastOnce()->yes(), $description);
+        $this->assertTrue($result->isSuperTypeOf(self::constantArrayFromRuntime([]))->no(), $description);
+        $this->assertTrue($result->isSuperTypeOf(self::constantArrayFromRuntime(['a' => 1]))->yes(), $description);
+        $this->assertTrue($result->isSuperTypeOf(self::constantArrayFromRuntime([2]))->yes(), $description);
+    }
+
     public function testSerializedBenevolentUnionRetainsReachableEmptyAlternative(): void
     {
         $merge = self::getContainer()->getByType(TypeStringResolver::class)->resolve(

tests/ArrayMergeTypeTest.php

@@ -186,7 +186,8 @@ public function testResolvePreservesBenevolentUnionWhenRemovingNeverAlternative(
             new BenevolentUnionType([$possiblyEmpty, $nonEmpty, new NeverType()]),
         ]))->resolve();
 
-        $this->assertTrue($withoutNever->isIterableAtLeastOnce()->yes());
+        $this->assertTrue($withoutNever->isIterableAtLeastOnce()->maybe());
+        $this->assertTrue($withoutNever->isSuperTypeOf(ConstantArrayTypeBuilder::createEmpty()->getArray())->yes());
         $this->assertTrue($withoutNever->equals($withNever));
     }