Do not map the sealed-array never marker in ConstantArrayType::mapValueType()

- `ConstantArrayType::mapValueType()` ran the callback over the unsealed value
  slot even for sealed arrays, where that slot is just the explicit-`never`
  marker. Callbacks that are not pure type transformers (e.g. the `array_map`
  callback evaluation, `array_walk`, array-dim assignments in loops) would
  replace the marker with whatever they returned and leak that type into the
  otherwise-sealed shape.
- For the reported case, evaluating `fn (SomeEnum $type) => $type->value` against
  the `never` marker produces an `ErrorType`, which `describe()` hides but
  `UnresolvableTypeHelper` (via `TypeTraverser`) finds, wrongly reporting
  "contains unresolvable type" on a fully-resolved `array{'foo'}`.
- Only transform the unsealed value type when the array is genuinely unsealed;
  otherwise keep the existing marker untouched. This central fix covers every
  caller of `mapValueType()`.
- Added a unit test on `ConstantArrayType::mapValueType()` and an
  AnalyserIntegrationTest reproducing the array_map + enum scenario under
  bleeding edge.

Author: phpstan-bot

src/Type/Constant/ConstantArrayType.php

@@ -3186,8 +3186,12 @@ public function mapValueType(callable $cb): Type
 			$newValueTypes[] = $cb($valueType);
 		}
 
-		$newUnsealed = $this->unsealed === null
-			? null
+		// For a sealed array the unsealed slot is just the explicit-never marker;
+		// running the callback over it would replace the marker with whatever the
+		// callback returns (e.g. an ErrorType from evaluating an array_map callback
+		// on `never`) and leak that type into the otherwise-sealed shape.
+		$newUnsealed = $this->unsealed === null || !$this->isUnsealed()->yes()
+			? $this->unsealed
 			: [$this->unsealed[0], $cb($this->unsealed[1])];
 
 		return $this->recreate(

tests/PHPStan/Analyser/AnalyserIntegrationTest.php

@@ -1608,6 +1608,13 @@ public function testBug14707(): void
 		$this->assertNoErrors($errors);
 	}
 
+	#[RequiresPhp('>= 8.1.0')]
+	public function testBug14844(): void
+	{
+		$errors = $this->runAnalyse(__DIR__ . '/data/bug-14844.php');
+		$this->assertNoErrors($errors);
+	}
+
 	/**
 	 * @param string[]|null $allAnalysedFiles
 	 * @return list<Error>

tests/PHPStan/Analyser/data/bug-14844.php

@@ -0,0 +1,35 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug14844;
+
+enum SomeEnum: string
+{
+	case FOO = 'foo';
+}
+
+class A
+{
+
+	/**
+	 * @return array<string>
+	 */
+	public function doBar(): array
+	{
+		return doFoo(
+			fn () => array_map(fn (SomeEnum $type) => $type->value, SomeEnum::cases()),
+		);
+	}
+
+}
+
+/**
+ * @template TReturn
+ * @param callable(): TReturn $callable
+ * @return TReturn
+ */
+function doFoo(callable $callable)
+{
+	return $callable();
+}

tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php

@@ -5,6 +5,7 @@
 use Closure;
 use PHPStan\DependencyInjection\BleedingEdgeToggle;
 use PHPStan\PhpDoc\TypeStringResolver;
+use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Testing\PHPStanTestCase;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Accessory\HasOffsetType;
@@ -13,6 +14,7 @@
 use PHPStan\Type\BooleanType;
 use PHPStan\Type\CallableType;
 use PHPStan\Type\ClassStringType;
+use PHPStan\Type\ErrorType;
 use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\Generic\GenericClassStringType;
 use PHPStan\Type\Generic\TemplateTypeFactory;
@@ -1619,6 +1621,28 @@ public function testSealedness(): void
 		});
 	}
 
+	public function testMapValueTypeKeepsSealedMarker(): void
+	{
+		BleedingEdgeToggle::withBleedingEdge(true, function () {
+			$array = new ConstantArrayType(
+				[new ConstantIntegerType(0)],
+				[new StringType()],
+				[1],
+				[],
+				TrinaryLogic::createYes(),
+			);
+			$this->assertSame(TrinaryLogic::createYes()->describe(), $array->isSealed()->describe());
+
+			// Evaluating an array_map callback against the sealed `never` marker
+			// produces an ErrorType (e.g. `$enum->value` on `never`). That ErrorType
+			// must not leak into the otherwise-sealed shape's unsealed slot.
+			$mapped = $array->mapValueType(static fn (Type $type): Type => $type instanceof NeverType ? new ErrorType() : new ConstantStringType('foo'));
+			$this->assertInstanceOf(ConstantArrayType::class, $mapped);
+			$this->assertSame(TrinaryLogic::createYes()->describe(), $mapped->isSealed()->describe());
+			$this->assertNull((new UnresolvableTypeHelper())->getUnresolvableType($mapped));
+		});
+	}
+
 	public static function dataGetArraySize(): iterable
 	{
 		$cases = [];