Address review comments

- Remove unnecessary toArrayKey() calls in resolveFiniteScalarKeyTypes()
- Use ConstantArrayTypeBuilder instead of recursion in setOffsetValueType()
- Remove CLAUDE.md changes
- Add test case for int<0, 5>|int<10, 15> union of integer ranges

Co-authored-by: Markus Staab <staabm@users.noreply.github.com>
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 3 people

CLAUDE.md

@@ -412,10 +412,6 @@ When adding or editing PHPDoc comments in this codebase, follow these guidelines
 - `symfony/console` - CLI interface
 - `hoa/compiler` - Used for regex type parsing
 
-### ConstantArrayType::setOffsetValueType union expansion for finite offsets
-
-When `ConstantArrayType::setOffsetValueType()` receives a union of constant string keys (e.g., `'a'|'b'`) or a finite `IntegerRangeType` (e.g., `int<1,5>`) and at least one key is new (not already in the array), it creates a union of constant arrays — one for each possible key — instead of degrading to a general `ArrayType`. This is controlled by `CHUNK_FINITE_TYPES_LIMIT` (5) to avoid combinatorial explosion in loops. Integer constant unions (e.g., `0|1` from loop fixpoint analysis) are excluded to prevent regression in loop analysis; only string constant unions and `IntegerRangeType` expansions are supported. The `resolveFiniteScalarKeyTypes()` helper method resolves the offset type to individual constant keys.
-
 ### Ternary expression type narrowing in TypeSpecifier
 
 `TypeSpecifier::specifyTypesInCondition()` handles ternary expressions (`$cond ? $a : $b`) for type narrowing. In a truthy context (e.g., inside `assert()`), the ternary is semantically equivalent to `($cond && $a) || (!$cond && $b)` — meaning if the condition is true, the "if" branch must be truthy, and if false, the "else" branch must be truthy. The fix converts ternary expressions to this `BooleanOr(BooleanAnd(...), BooleanAnd(...))` form so the existing OR/AND narrowing logic handles both branches correctly. This enables `assert($cond ? $x instanceof A : $x instanceof B)` to narrow `$x` to `A|B`. The `AssertFunctionTypeSpecifyingExtension` calls `specifyTypesInCondition` with `TypeSpecifierContext::createTruthy()` context for the assert argument.

src/Type/Constant/ConstantArrayType.php

@@ -722,7 +722,9 @@ public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $uni
 				if ($hasNewKey) {
 					$arrayTypes = [];
 					foreach ($scalarKeyTypes as $scalarKeyType) {
-						$arrayTypes[] = $this->setOffsetValueType($scalarKeyType, $valueType, $unionValues);
+						$builder = ConstantArrayTypeBuilder::createFromConstantArray($this);
+						$builder->setOffsetValueType($scalarKeyType, $valueType);
+						$arrayTypes[] = $builder->getArray();
 					}
 
 					return TypeCombinator::union(...$arrayTypes);
@@ -756,8 +758,7 @@ private function resolveFiniteScalarKeyTypes(Type $offsetType): ?array
 		if (count($constantStrings) >= 2 && count($constantStrings) <= self::CHUNK_FINITE_TYPES_LIMIT) {
 			$result = [];
 			foreach ($constantStrings as $constantString) {
-				$arrayKeyType = $constantString->toArrayKey();
-				$scalarValues = $arrayKeyType->getConstantScalarValues();
+				$scalarValues = $constantString->getConstantScalarValues();
 				if (count($scalarValues) !== 1) {
 					return null;
 				}
@@ -793,11 +794,10 @@ private function resolveFiniteScalarKeyTypes(Type $offsetType): ?array
 
 			$result = [];
 			foreach ($finiteScalarTypes as $scalarType) {
-				$arrayKeyType = $scalarType->toArrayKey();
-				if (!$arrayKeyType instanceof ConstantIntegerType) {
+				if (!$scalarType instanceof ConstantIntegerType) {
 					return null;
 				}
-				$result[] = $arrayKeyType;
+				$result[] = $scalarType;
 			}
 			return $result;
 		}

tests/PHPStan/Analyser/nsrt/set-constant-union-offset-on-constant-array.php

@@ -37,6 +37,16 @@ public function doInfiniteRange(array $a, $intRange): void
 		assertType('non-empty-array<\'foo\'|int<0, max>, int>', $a);
 	}
 
+	/**
+	 * @param array{foo: int}  $a
+	 * @param int<0, 5>|int<10, 15> $intRange
+	 */
+	public function doUnionOfRanges(array $a, $intRange): void
+	{
+		$a[$intRange] = 256;
+		assertType('non-empty-array<\'foo\'|int<0, 5>|int<10, 15>, int>', $a);
+	}
+
 	/**
 	 * @param array{0: 'a', 1: 'b'}  $a
 	 * @param int<0,1> $intRange