TypeCombinator::union optimization in case of many *NEVER*

Merge the separate NeverType pre-scan into the existing flattening
loop, eliminating the redundant iteration over all types.

Also skip the classification loop and inline the dedup for the common
case of 2 non-scalar, non-array, non-enum types.

Author: SanderMuller

src/Type/TypeCombinator.php

@@ -188,58 +188,12 @@ public static function union(Type ...$types): Type
 			}
 		}
 
-		// Fast path for N>2: strip implicit NeverTypes and short-circuit on mixed
-		if ($typesCount > 2) {
-			$neverCount = 0;
-			$hasUnionOrBenevolent = false;
-			for ($i = 0; $i < $typesCount; $i++) {
-				$t = $types[$i];
-				if (
-					$t instanceof MixedType
-					&& !$t->isExplicitMixed()
-					&& !$t instanceof TemplateMixedType
-					&& $t->getSubtractedType() === null
-				) {
-					return $t;
-				}
-				if ($t instanceof NeverType && !$t->isExplicit()) {
-					$neverCount++;
-				} elseif ($t instanceof UnionType && !$t instanceof TemplateType) {
-					$hasUnionOrBenevolent = true;
-				}
-			}
-
-			if ($neverCount > 0 && !$hasUnionOrBenevolent) {
-				if ($neverCount === $typesCount) {
-					return new NeverType();
-				}
-
-				$filtered = [];
-				for ($i = 0; $i < $typesCount; $i++) {
-					if ($types[$i] instanceof NeverType && !$types[$i]->isExplicit()) {
-						continue;
-					}
-
-					$filtered[] = $types[$i];
-				}
-				$filteredCount = count($filtered);
-
-				if ($filteredCount === 1 && !$filtered[0]->isArray()->yes()) {
-					return $filtered[0];
-				}
-				if ($filteredCount === 2) {
-					return self::union($filtered[0], $filtered[1]);
-				}
-				$types = $filtered;
-				$typesCount = $filteredCount;
-			}
-		}
-
 		$alreadyNormalized = [];
 		$alreadyNormalizedCounter = 0;
 
 		$benevolentTypes = [];
 		$benevolentUnionObject = null;
+		$neverCount = 0;
 		// transform A | (B | C) to A | B | C
 		for ($i = 0; $i < $typesCount; $i++) {
 			if (
@@ -251,8 +205,7 @@ public static function union(Type ...$types): Type
 				return $types[$i];
 			}
 			if ($types[$i] instanceof NeverType && !$types[$i]->isExplicit()) {
-				array_splice($types, $i--, 1);
-				$typesCount--;
+				$neverCount++;
 				continue;
 			}
 			if ($types[$i] instanceof BenevolentUnionType) {
@@ -283,6 +236,33 @@ public static function union(Type ...$types): Type
 			$typesCount += count($typesInner) - 1;
 		}
 
+		// Bulk-remove implicit NeverTypes (skipped during the loop above)
+		if ($neverCount > 0) {
+			if ($neverCount === $typesCount) {
+				return new NeverType();
+			}
+
+			$filtered = [];
+			for ($i = 0; $i < $typesCount; $i++) {
+				if ($types[$i] instanceof NeverType && !$types[$i]->isExplicit()) {
+					continue;
+				}
+				$filtered[] = $types[$i];
+			}
+			$types = $filtered;
+			$typesCount = count($types);
+
+			if ($typesCount === 0) {
+				return new NeverType();
+			}
+			if ($typesCount === 1 && !$types[0]->isArray()->yes()) {
+				return $types[0];
+			}
+			if ($typesCount === 2) {
+				return self::union($types[0], $types[1]);
+			}
+		}
+
 		if ($typesCount === 0) {
 			return new NeverType();
 		}
@@ -296,6 +276,21 @@ public static function union(Type ...$types): Type
 		$hasGenericScalarTypes = [];
 		$enumCaseTypes = [];
 		$integerRangeTypes = [];
+
+		// For 2 non-scalar, non-array, non-enum types: skip the classification loop
+		if ($typesCount === 2
+			&& !$types[0] instanceof ConstantScalarType
+			&& !$types[1] instanceof ConstantScalarType
+			&& !$types[0] instanceof IntegerRangeType
+			&& !$types[1] instanceof IntegerRangeType
+			&& $types[0]->getEnumCaseObject() === null
+			&& $types[1]->getEnumCaseObject() === null
+			&& !$types[0]->isArray()->yes()
+			&& !$types[1]->isArray()->yes()
+		) {
+			goto skipClassification;
+		}
+
 		for ($i = 0; $i < $typesCount; $i++) {
 			if ($types[$i]->isConstantScalarValue()->yes()) {
 				$type = $types[$i];
@@ -337,13 +332,17 @@ public static function union(Type ...$types): Type
 			unset($types[$i]);
 		}
 
-		$enumCaseTypes = array_values($enumCaseTypes);
-		usort(
-			$integerRangeTypes,
-			static fn (IntegerRangeType $a, IntegerRangeType $b): int => ($a->getMin() ?? PHP_INT_MIN) <=> ($b->getMin() ?? PHP_INT_MIN)
-				?: ($a->getMax() ?? PHP_INT_MAX) <=> ($b->getMax() ?? PHP_INT_MAX),
-		);
-		$types = array_merge($types, $integerRangeTypes);
+		if ($enumCaseTypes !== []) {
+			$enumCaseTypes = array_values($enumCaseTypes);
+		}
+		if ($integerRangeTypes !== []) {
+			usort(
+				$integerRangeTypes,
+				static fn (IntegerRangeType $a, IntegerRangeType $b): int => ($a->getMin() ?? PHP_INT_MIN) <=> ($b->getMin() ?? PHP_INT_MIN)
+					?: ($a->getMax() ?? PHP_INT_MAX) <=> ($b->getMax() ?? PHP_INT_MAX),
+			);
+			$types = array_merge($types, $integerRangeTypes);
+		}
 		$types = array_values($types);
 		$typesCount = count($types);
 
@@ -387,7 +386,7 @@ public static function union(Type ...$types): Type
 			$scalarTypes[$classType] = $scalarTypeItems;
 		}
 
-		if (count($types) > 16) {
+		if ($typesCount > 16 && count($types) > 16) {
 			$newTypes = [];
 			foreach ($types as $type) {
 				$newTypes[$type->describe(VerbosityLevel::cache())] = $type;
@@ -401,30 +400,45 @@ public static function union(Type ...$types): Type
 		);
 		$typesCount = count($types);
 
+		skipClassification:
 		// transform A | A to A
 		// transform A | never to A
-		for ($i = 0; $i < $typesCount; $i++) {
-			for ($j = $i + 1; $j < $typesCount; $j++) {
-				if (self::isAlreadyNormalized($alreadyNormalized, $types[$i], $types[$j])) {
-					continue;
-				}
-				$compareResult = self::compareTypesInUnion($types[$i], $types[$j]);
-				if ($compareResult === null) {
-					continue;
-				}
-
+		if ($typesCount === 2 && $alreadyNormalized === []) {
+			$compareResult = self::compareTypesInUnion($types[0], $types[1]);
+			if ($compareResult !== null) {
 				[$a, $b] = $compareResult;
 				if ($a !== null) {
-					$types[$i] = $a;
-					array_splice($types, $j--, 1);
-					$typesCount--;
-					continue 1;
+					$types = [$a];
+					$typesCount = 1;
+				} elseif ($b !== null) {
+					$types = [$b];
+					$typesCount = 1;
 				}
-				if ($b !== null) {
-					$types[$j] = $b;
-					array_splice($types, $i--, 1);
-					$typesCount--;
-					continue 2;
+			}
+		} else {
+			for ($i = 0; $i < $typesCount; $i++) {
+				for ($j = $i + 1; $j < $typesCount; $j++) {
+					if (self::isAlreadyNormalized($alreadyNormalized, $types[$i], $types[$j])) {
+						continue;
+					}
+					$compareResult = self::compareTypesInUnion($types[$i], $types[$j]);
+					if ($compareResult === null) {
+						continue;
+					}
+
+					[$a, $b] = $compareResult;
+					if ($a !== null) {
+						$types[$i] = $a;
+						array_splice($types, $j--, 1);
+						$typesCount--;
+						continue 1;
+					}
+					if ($b !== null) {
+						$types[$j] = $b;
+						array_splice($types, $i--, 1);
+						$typesCount--;
+						continue 2;
+					}
 				}
 			}
 		}