TrinaryLogic for isList in ConstantArrayType

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -59,6 +59,7 @@
 use function count;
 use function implode;
 use function in_array;
+use function is_bool;
 use function is_int;
 use function is_string;
 use function min;
@@ -76,6 +77,8 @@ class ConstantArrayType extends ArrayType implements ConstantType
 
 private const DESCRIBE_LIMIT = 8;
 
+private TrinaryLogic $isList;
+
 /** @var self[]|null */
 private ?array $allArrays = null;
 
@@ -94,7 +97,7 @@ public function __construct(
 private array $valueTypes,
 int|array $nextAutoIndexes = [0],
 private array $optionalKeys = [],
-private bool $isList = false,
+bool|TrinaryLogic $isList = false,
 )
 {
 assert(count($keyTypes) === count($valueTypes));
@@ -108,13 +111,18 @@ public function __construct(
 $keyTypesCount = count($this->keyTypes);
 if ($keyTypesCount === 0) {
 $keyType = new NeverType(true);
-$this->isList = true;
+$isList = TrinaryLogic::createYes();
 } elseif ($keyTypesCount === 1) {
 $keyType = $this->keyTypes[0];
 } else {
 $keyType = new UnionType($this->keyTypes);
 }
 
+if (is_bool($isList)) {
+$isList = TrinaryLogic::createFromBoolean($isList);
+}
+$this->isList = $isList;
+
 parent::__construct(
 $keyType,
 count($valueTypes) > 0 ? TypeCombinator::union(...$valueTypes) : new NeverType(true),
@@ -192,7 +200,7 @@ public function getAllArrays(): array
 $keys = array_merge($requiredKeys, $combination);
 sort($keys);
 
-if ($this->isList && array_keys($keys) !== array_values($keys)) {
+if ($this->isList->yes() && array_keys($keys) !== array_values($keys)) {
 continue;
 }
 
@@ -841,7 +849,7 @@ public function shuffleArray(): Type
 if ($isIterableAtLeastOnce->yes()) {
 $generalizedArray = TypeCombinator::intersect($generalizedArray, new NonEmptyArrayType());
 }
-if ($valuesArray->isList) {
+if ($valuesArray->isList->yes()) {
 $generalizedArray = AccessoryArrayListType::intersectWith($generalizedArray);
 }
 
@@ -933,7 +941,7 @@ public function isConstantArray(): TrinaryLogic
 
 public function isList(): TrinaryLogic
 {
-return TrinaryLogic::createFromBoolean($this->isList);
+return $this->isList;
 }
 
 /** @deprecated Use popArray() instead */
@@ -1122,7 +1130,7 @@ public function reverse(bool $preserveKeys = false): self
 $keyTypesReversedKeys = array_keys($keyTypesReversed);
 $optionalKeys = array_map(static fn (int $optionalKey): int => $keyTypesReversedKeys[$optionalKey], $this->optionalKeys);
 
-$reversed = new self($keyTypes, array_reverse($this->valueTypes), $this->nextAutoIndexes, $optionalKeys, false);
+$reversed = new self($keyTypes, array_reverse($this->valueTypes), $this->nextAutoIndexes, $optionalKeys, TrinaryLogic::createNo());
 
 return $preserveKeys ? $reversed : $reversed->reindex();
 }
@@ -1161,7 +1169,7 @@ private function reindex(): self
 $autoIndex++;
 }
 
-return new self($keyTypes, $this->valueTypes, [$autoIndex], $this->optionalKeys, true);
+return new self($keyTypes, $this->valueTypes, [$autoIndex], $this->optionalKeys, TrinaryLogic::createYes());
 }
 
 public function toBoolean(): BooleanType
@@ -1247,7 +1255,7 @@ public function generalizeToArray(): Type
 if ($isIterableAtLeastOnce->yes()) {
 $arrayType = TypeCombinator::intersect($arrayType, new NonEmptyArrayType());
 }
-if ($this->isList) {
+if ($this->isList->yes()) {
 $arrayType = AccessoryArrayListType::intersectWith($arrayType);
 }
 
@@ -1279,13 +1287,13 @@ private function getKeysOrValuesArray(array $types): self
 $autoIndexes = range($count - count($this->optionalKeys), $count);
 assert($autoIndexes !== []);
 
-if ($this->isList) {
+if ($this->isList->yes()) {
 // Optimized version for lists: Assume that if a later key exists, then earlier keys also exist.
 $keyTypes = array_map(
 static fn (int $i): ConstantIntegerType => new ConstantIntegerType($i),
 array_keys($types),
 );
-return new self($keyTypes, $types, $autoIndexes, $this->optionalKeys, true);
+return new self($keyTypes, $types, $autoIndexes, $this->optionalKeys, TrinaryLogic::createYes());
 }
 
 $keyTypes = [];
@@ -1314,7 +1322,7 @@ private function getKeysOrValuesArray(array $types): self
 $maxIndex++;
 }
 
-return new self($keyTypes, $valueTypes, $autoIndexes, $optionalKeys, true);
+return new self($keyTypes, $valueTypes, $autoIndexes, $optionalKeys, TrinaryLogic::createYes());
 }
 
 /** @deprecated Use getArraySize() instead */
@@ -1539,7 +1547,7 @@ public function mergeWith(self $otherArray): self
 $nextAutoIndexes = array_values(array_unique(array_merge($this->nextAutoIndexes, $otherArray->nextAutoIndexes)));
 sort($nextAutoIndexes);
 
-return new self($this->keyTypes, $valueTypes, $nextAutoIndexes, $optionalKeys, $this->isList && $otherArray->isList);
+return new self($this->keyTypes, $valueTypes, $nextAutoIndexes, $optionalKeys, $this->isList->and($otherArray->isList));
 }
 
 /**
@@ -1680,7 +1688,7 @@ public function getFiniteTypes(): array
  */
 public static function __set_state(array $properties): Type
 {
-return new self($properties['keyTypes'], $properties['valueTypes'], $properties['nextAutoIndexes'] ?? $properties['nextAutoIndex'], $properties['optionalKeys'] ?? []);
+return new self($properties['keyTypes'], $properties['valueTypes'], $properties['nextAutoIndexes'] ?? $properties['nextAutoIndex'], $properties['optionalKeys'] ?? [], $properties['isList'] ?? TrinaryLogic::createNo());
 }
 
 }