Avoid 2^N getAllArrays() expansion in implode() return type extension

Process keys incrementally instead of generating all power-set variants
upfront via `getAllArrays()`. For each key, fork partial results for
optional keys and bail early when the count exceeds
`CALCULATE_SCALARS_LIMIT`. This avoids allocating 2^N
`ConstantArrayType` objects for N optional keys.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ondrejmirtes

src/Type/Php/ImplodeFunctionReturnTypeExtension.php

@@ -5,7 +5,6 @@
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\AutowiredService;
-use PHPStan\Internal\CombinationsHelper;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\InitializerExprTypeResolver;
 use PHPStan\Type\Accessory\AccessoryLiteralStringType;
@@ -113,33 +112,45 @@ private function implode(Type $arrayType, Type $separatorType): Type
 
 	private function inferConstantType(ConstantArrayType $arrayType, ConstantStringType $separatorType): ?Type
 	{
-		$strings = [];
-		foreach ($arrayType->getAllArrays() as $array) {
-			$valueTypes = $array->getValueTypes();
-
-			$arrayValues = [];
-			$combinationsCount = 1;
-			foreach ($valueTypes as $valueType) {
-				$constScalars = $valueType->getConstantScalarValues();
-				if (count($constScalars) === 0) {
-					return null;
-				}
-				$arrayValues[] = $constScalars;
-				$combinationsCount *= count($constScalars);
+		$sep = $separatorType->getValue();
+		$valueTypes = $arrayType->getValueTypes();
+		$limit = InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT;
+
+		// Build implode results incrementally, processing one key at a time.
+		// For optional keys, fork each partial result into with/without variants.
+		// This avoids generating 2^N ConstantArrayType objects via getAllArrays().
+		/** @var list<list<scalar>> $partials */
+		$partials = [[]];
+
+		foreach ($valueTypes as $i => $valueType) {
+			$constScalars = $valueType->getConstantScalarValues();
+			if (count($constScalars) === 0) {
+				return null;
 			}
 
-			if ($combinationsCount > InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT) {
-				return null;
+			$isOptional = $arrayType->isOptionalKey($i);
+			$newPartials = [];
+
+			foreach ($partials as $partial) {
+				if ($isOptional) {
+					$newPartials[] = $partial;
+				}
+				foreach ($constScalars as $scalar) {
+					$newPartial = $partial;
+					$newPartial[] = $scalar;
+					$newPartials[] = $newPartial;
+				}
 			}
 
-			$combinations = CombinationsHelper::combinations($arrayValues);
-			foreach ($combinations as $combination) {
-				$strings[] = new ConstantStringType(implode($separatorType->getValue(), $combination));
+			$partials = $newPartials;
+			if (count($partials) > $limit) {
+				return null;
 			}
 		}
 
-		if (count($strings) > InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT) {
-			return null;
+		$strings = [];
+		foreach ($partials as $partial) {
+			$strings[] = new ConstantStringType(implode($sep, $partial));
 		}
 
 		return TypeCombinator::union(...$strings);

tests/bench/data/implode-optional-keys-blowup.php

@@ -0,0 +1,20 @@
+<?php declare(strict_types = 1);
+
+namespace BenchImplodeOptionalKeysBlowup;
+
+/**
+ * Regression test for implode() calling getAllArrays() on arrays with many optional keys.
+ * getAllArrays() generates 2^N ConstantArrayType objects for N optional keys.
+ * The fix processes keys incrementally, bailing early when partial count exceeds the limit.
+ *
+ * @param array{
+ *     a?: 'x', b?: 'x', c?: 'x', d?: 'x', e?: 'x',
+ *     f?: 'x', g?: 'x', h?: 'x', i?: 'x', j?: 'x',
+ *     k?: 'x', l?: 'x', m?: 'x', n?: 'x', o?: 'x',
+ *     p?: 'x', q?: 'x', r?: 'x', s?: 'x', t?: 'x'
+ * } $data
+ */
+function joinOptional(array $data): string
+{
+	return implode(',', $data);
+}