Faster TypeCombinator

src/Type/TypeCombinator.php

@@ -1051,7 +1051,7 @@
 		if ($constantArrayValuesCount <= ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT) {
 			return $types;
 		}
 
 		// Stage 1: collapse same-key-set ConstantArrayType variants per-position
 		// before the (lossy) generalization below kicks in. Variants with the
 		// same key signature mergeWith losslessly into a single shape whose
@@ -1064,7 +1064,7 @@
 		$signatureGroups = [];
 		$nonConstantTypes = [];
 		foreach ($types as $idx => $type) {
 			if (!$type instanceof ConstantArrayType) {
 				$nonConstantTypes[$idx] = $type;
 				continue;
 			}
@@ -1609,9 +1609,14 @@
 		$newTypes = [];
 		$hasOffsetValueTypeCount = 0;
 		$typesCount = count($types);
+		$typesNeedSorting = false;
 		for ($i = 0; $i < $typesCount; $i++) {
 			$type = $types[$i];
 
+			if ($type instanceof SubtractableType || $type instanceof ConstantArrayType) {
+				$typesNeedSorting = true;
+			}
+
 			if ($type instanceof IntersectionType && !$type instanceof TemplateType) {
 				// transform A & (B & C) to A & B & C
 				array_splice($types, $i--, 1, $type->getTypes());
@@ -1629,24 +1634,26 @@
 			$typesCount = count($types);
 		}
 
-		usort($types, static function (Type $a, Type $b): int {
-			// move subtractables with subtracts before those without to avoid losing them in the union logic
-			if ($a instanceof SubtractableType && $a->getSubtractedType() !== null) {
-				return -1;
-			}
-			if ($b instanceof SubtractableType && $b->getSubtractedType() !== null) {
-				return 1;
-			}
+		if ($typesNeedSorting) {
+			usort($types, static function (Type $a, Type $b): int {
+				// move subtractables with subtracts before those without to avoid losing them in the union logic
+				if ($a instanceof SubtractableType && $a->getSubtractedType() !== null) {
+					return -1;
+				}
+				if ($b instanceof SubtractableType && $b->getSubtractedType() !== null) {
+					return 1;
+				}
 
-			if ($a instanceof ConstantArrayType && !$b instanceof ConstantArrayType) {
-				return -1;
-			}
-			if ($b instanceof ConstantArrayType && !$a instanceof ConstantArrayType) {
-				return 1;
-			}
+				if ($a instanceof ConstantArrayType && !$b instanceof ConstantArrayType) {
+					return -1;
+				}
+				if ($b instanceof ConstantArrayType && !$a instanceof ConstantArrayType) {
+					return 1;
+				}
 
-			return 0;
-		});
+				return 0;
+			});
+		}
 
 		// transform IntegerType & ConstantIntegerType to ConstantIntegerType
 		// transform Child & Parent to Child
@@ -1878,7 +1885,7 @@
 							$newArrayType = $newArray->getArray();
 						}
 
 						if ($constArrayIsI) {
 							$types[$i] = $newArrayType;
 							array_splice($types, $j--, 1);
 						} else {
@@ -1891,7 +1898,7 @@
 
 					if (
 						($types[$i] instanceof ArrayType || $types[$i] instanceof ConstantArrayType || $types[$i] instanceof IterableType) &&
 						($types[$j] instanceof ArrayType || $types[$j] instanceof ConstantArrayType || $types[$j] instanceof IterableType)
 					) {
 						$keyType = self::intersect($types[$i]->getIterableKeyType(), $types[$j]->getKeyType());
 						$itemType = self::intersect($types[$i]->getItemType(), $types[$j]->getItemType());