Generalize NeverType handling for member access in MutatingScope

Move the NeverType-instead-of-ErrorType fix from individual handlers
(PropertyFetchHandler, MethodCallHandler) to MutatingScope::resolveType().
This provides a single central fix: when any handler returns ErrorType for
a member access on NeverType (dead code branch after type narrowing), it is
converted to NeverType. This ensures TypeCombinator::union() correctly
eliminates the dead branch type instead of polluting the union with mixed.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: phpstan-bot

src/Analyser/ExprHandler/MethodCallHandler.php

@@ -289,11 +289,6 @@ private function getMethodThrowPoint(MethodReflection $methodReflection, Paramet
 
 	public function resolveType(MutatingScope $scope, Expr $expr): Type
 	{
-		$calledOnType = $scope->getType($expr->var);
-		if ($calledOnType instanceof NeverType) {
-			return new NeverType();
-		}
-
 		if ($expr->name instanceof Identifier) {
 			if ($scope->nativeTypesPromoted) {
 				$methodReflection = $scope->getMethodReflection(

src/Analyser/ExprHandler/PropertyFetchHandler.php

@@ -20,7 +20,6 @@
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\MixedType;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use function array_map;
@@ -91,11 +90,6 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 
 	public function resolveType(MutatingScope $scope, Expr $expr): Type
 	{
-		$fetchedOnType = $scope->getType($expr->var);
-		if ($fetchedOnType instanceof NeverType) {
-			return new NeverType();
-		}
-
 		if ($expr->name instanceof Identifier) {
 			if ($scope->nativeTypesPromoted) {
 				$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($expr, $scope);

src/Analyser/MutatingScope.php

@@ -982,12 +982,32 @@ private function resolveType(string $exprString, Expr $node): Type
 				continue;
 			}
 
-			return $exprHandler->resolveType($this, $node);
+			$type = $exprHandler->resolveType($this, $node);
+
+			// When a member access is performed on NeverType (e.g. in a dead code
+			// branch after type narrowing), the handler can't find the member and
+			// returns ErrorType. Since ErrorType extends MixedType, it pollutes
+			// type unions (e.g. union(ErrorType, string) = mixed instead of string).
+			// The correct result is NeverType, which is eliminated from unions.
+			if ($type instanceof ErrorType && $this->resolvedMemberAccessOnNeverType($node)) {
+				return new NeverType();
+			}
+
+			return $type;
 		}
 
 		return new MixedType();
 	}
 
+	private function resolvedMemberAccessOnNeverType(Expr $node): bool
+	{
+		if ($node instanceof PropertyFetch || $node instanceof MethodCall) {
+			return $this->getType($node->var) instanceof NeverType;
+		}
+
+		return false;
+	}
+
 	/**
 	 * @param callable(Type): ?bool $typeCallback
 	 */