Return TrinaryLogic from expressionContainsNonPureCall

Return TrinaryLogic::createMaybe() when reflection cannot be resolved
for a callable, distinguishing it from definitely-impure calls (yes)
and definitely-pure calls (no).

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

Author: phpstan-bot

src/Analyser/TypeSpecifier.php

@@ -2538,7 +2538,7 @@ private function createForExpr(
 			}
 		}
 
-		if (!($expr instanceof AlwaysRememberedExpr) && $this->expressionContainsNonPureCall($expr, $scope)) {
+		if (!($expr instanceof AlwaysRememberedExpr) && !$this->expressionContainsNonPureCall($expr, $scope)->no()) {
 			if (isset($containsNull) && !$containsNull) {
 				return $this->createNullsafeTypes($originalExpr, $scope, $context, $type);
 			}
@@ -2574,76 +2574,84 @@ private function createForExpr(
 		return $types;
 	}
 
-	private function expressionContainsNonPureCall(Expr $expr, Scope $scope): bool
+	private function expressionContainsNonPureCall(Expr $expr, Scope $scope): TrinaryLogic
 	{
 		$nodeFinder = new NodeFinder();
-		$found = $nodeFinder->findFirst([$expr], function (Node $node) use ($scope): bool {
-			if (!$node instanceof Expr) {
-				return false;
-			}
+		$callNodes = $nodeFinder->find([$expr], static function (Node $node): bool {
+			return $node instanceof FuncCall || $node instanceof MethodCall || $node instanceof StaticCall;
+		});
 
-			if ($node instanceof FuncCall) {
-				if ($node->name instanceof Name) {
-					if (!$this->reflectionProvider->hasFunction($node->name, $scope)) {
-						return true;
+		$result = TrinaryLogic::createNo();
+		foreach ($callNodes as $callNode) {
+			if ($callNode instanceof FuncCall) {
+				if ($callNode->name instanceof Name) {
+					if (!$this->reflectionProvider->hasFunction($callNode->name, $scope)) {
+						$result = $result->or(TrinaryLogic::createMaybe());
+						continue;
 					}
-					$hasSideEffects = $this->reflectionProvider->getFunction($node->name, $scope)->hasSideEffects();
-					return $hasSideEffects->yes()
-						|| (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no());
-				}
-
-				$nameType = $scope->getType($node->name);
-				if ($nameType->isCallable()->yes()) {
-					$isPure = null;
-					foreach ($nameType->getCallableParametersAcceptors($scope) as $variant) {
-						$variantIsPure = $variant->isPure();
-						$isPure = $isPure === null ? $variantIsPure : $isPure->and($variantIsPure);
+					$hasSideEffects = $this->reflectionProvider->getFunction($callNode->name, $scope)->hasSideEffects();
+					if ($hasSideEffects->yes()
+						|| (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no())) {
+						return TrinaryLogic::createYes();
 					}
-					if ($isPure !== null) {
-						return $isPure->no()
-							|| (!$this->rememberPossiblyImpureFunctionValues && !$isPure->yes());
+				} else {
+					$nameType = $scope->getType($callNode->name);
+					if ($nameType->isCallable()->yes()) {
+						$isPure = null;
+						foreach ($nameType->getCallableParametersAcceptors($scope) as $variant) {
+							$variantIsPure = $variant->isPure();
+							$isPure = $isPure === null ? $variantIsPure : $isPure->and($variantIsPure);
+						}
+						if ($isPure !== null
+							&& ($isPure->no() || (!$this->rememberPossiblyImpureFunctionValues && !$isPure->yes()))) {
+							return TrinaryLogic::createYes();
+						}
 					}
 				}
-
-				return false;
-			}
-
-			if ($node instanceof MethodCall) {
-				if ($node->name instanceof Identifier) {
-					$calledOnType = $scope->getType($node->var);
-					$methodReflection = $scope->getMethodReflection($calledOnType, $node->name->name);
+			} elseif ($callNode instanceof MethodCall) {
+				if ($callNode->name instanceof Identifier) {
+					$calledOnType = $scope->getType($callNode->var);
+					$methodReflection = $scope->getMethodReflection($calledOnType, $callNode->name->name);
 					if ($methodReflection === null) {
-						return true;
+						$result = $result->or(TrinaryLogic::createMaybe());
+						continue;
 					}
 					$hasSideEffects = $methodReflection->hasSideEffects();
-					return $hasSideEffects->yes()
-						|| (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no());
+					if ($hasSideEffects->yes()
+						|| (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no())) {
+						return TrinaryLogic::createYes();
+					}
+				} else {
+					$result = $result->or(TrinaryLogic::createMaybe());
 				}
-				return true;
-			}
-
-			if ($node instanceof StaticCall) {
-				if ($node->name instanceof Identifier) {
-					if ($node->class instanceof Name) {
-						$calledOnType = $scope->resolveTypeByName($node->class);
+			} elseif ($callNode instanceof StaticCall) {
+				if ($callNode->name instanceof Identifier) {
+					if ($callNode->class instanceof Name) {
+						$calledOnType = $scope->resolveTypeByName($callNode->class);
 					} else {
-						$calledOnType = $scope->getType($node->class);
+						$calledOnType = $scope->getType($callNode->class);
 					}
-					$methodReflection = $scope->getMethodReflection($calledOnType, $node->name->name);
+					$methodReflection = $scope->getMethodReflection($calledOnType, $callNode->name->name);
 					if ($methodReflection === null) {
-						return true;
+						$result = $result->or(TrinaryLogic::createMaybe());
+						continue;
 					}
 					$hasSideEffects = $methodReflection->hasSideEffects();
-					return $hasSideEffects->yes()
-						|| (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no());
+					if ($hasSideEffects->yes()
+						|| (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no())) {
+						return TrinaryLogic::createYes();
+					}
+				} else {
+					$result = $result->or(TrinaryLogic::createMaybe());
 				}
-				return true;
 			}
 
-			return false;
-		});
+			if ($result->yes()) {
+				return $result;
+			}
+		}
 
-		return $found !== null;
+		return $result;
 	}
 
 	private function createNullsafeTypes(Expr $expr, Scope $scope, TypeSpecifierContext $context, ?Type $type): SpecifiedTypes