address feedback

Author: staabm

phpstan-baseline.neon

@@ -1824,7 +1824,7 @@ parameters:
 		-
 			message: '#^Doing instanceof PHPStan\\Type\\IntersectionType is error\-prone and deprecated\.$#'
 			identifier: phpstanApi.instanceofType
-			count: 3
+			count: 4
 			path: src/Type/TypeUtils.php
 
 		-

src/Analyser/NodeScopeResolver.php

@@ -5139,21 +5139,20 @@ private function processArgs(
 				$scopeToPass = $closureBindScope;
 			}
 
-			if (
-				$parameterType === null
-				|| $parameterType instanceof MixedType
-				|| $parameterType->isCallable()->no()
-			) {
-				$callCallbackImmediately = false;
-			} elseif ($parameter instanceof ExtendedParameterReflection) {
+			$parameterCallableType = null;
+			if ($parameterType !== null) {
+				$parameterCallableType = TypeUtils::findCallableType($parameterType);
+			}
+
+			if ($parameter instanceof ExtendedParameterReflection) {
 				$parameterCallImmediately = $parameter->isImmediatelyInvokedCallable();
 				if ($parameterCallImmediately->maybe()) {
-					$callCallbackImmediately = $calleeReflection instanceof FunctionReflection;
+					$callCallbackImmediately = $parameterCallableType !== null && $calleeReflection instanceof FunctionReflection;
 				} else {
 					$callCallbackImmediately = $parameterCallImmediately->yes();
 				}
 			} else {
-				$callCallbackImmediately = $calleeReflection instanceof FunctionReflection;
+				$callCallbackImmediately = $parameterCallableType !== null && $calleeReflection instanceof FunctionReflection;
 			}
 
 			if ($arg->value instanceof Expr\Closure) {

src/Type/TypeUtils.php

@@ -170,6 +170,24 @@ public static function findThisType(Type $type): ?ThisType
 		return null;
 	}
 
+	public static function findCallableType(Type $type): ?Type
+	{
+		if ($type->isCallable()->yes()) {
+			return $type;
+		}
+
+		if ($type instanceof UnionType || $type instanceof IntersectionType) {
+			foreach ($type->getTypes() as $innerType) {
+				$callableType = self::findCallableType($innerType);
+				if ($callableType !== null) {
+					return $callableType;
+				}
+			}
+		}
+
+		return null;
+	}
+
 	/**
 	 * @return HasPropertyType[]
 	 */

tests/PHPStan/Rules/Pure/PureFunctionRuleTest.php

@@ -116,6 +116,18 @@ public function testRule(): void
 				'Impure call to function array_push() in pure function PureFunction\bug13288().',
 				182,
 			],
+			[
+				'Impure exit in pure function PureFunction\bug13288b().',
+				200,
+			],
+			[
+				'Impure exit in pure function PureFunction\bug13288c().',
+				217,
+			],
+			[
+				'Impure exit in pure function PureFunction\bug13288d().',
+				230,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Pure/data/pure-function.php

@@ -168,19 +168,84 @@ function justContainsInlineHtml()
 /** @phpstan-pure */
 function bug13288(array $a)
 {
-	array_push($a, function() { // error because by ref arg
+	array_push($a, function () { // error because by ref arg
 		exit(); // ok, as array_push() will not invoke the function
 	});
 
 	array_push($a, // error because by ref arg
 		fn() => exit() // ok, as array_push() will not invoke the function
 	);
 
-	$closure = function() {
+	$exitingClosure = function () {
 		exit();
 	};
 	array_push($a, // error because by ref arg
-		$closure // ok, as array_push() will not invoke the function
+		$exitingClosure // ok, as array_push() will not invoke the function
 	);
+
+	takesString("exit"); // ok, as the maybe callable type string is not typed with immediately-invoked-callable
+}
+
+/** @phpstan-pure */
+function takesString(string $s) {
+}
+
+/** @phpstan-pure */
+function bug13288b()
+{
+	$exitingClosure = function () {
+		exit();
+	};
+
+	takesMixed($exitingClosure); // error because immediately invoked
+}
+
+/**
+ * @phpstan-pure
+ * @param-immediately-invoked-callable $m
+ */
+function takesMixed(mixed $m) {
+}
+
+/** @phpstan-pure */
+function bug13288c()
+{
+	$exitingClosure = function () {
+		exit();
+	};
+
+	takesMaybeCallable($exitingClosure);
+}
+
+/** @phpstan-pure */
+function takesMaybeCallable(?callable $c) { // arguments passed to functions are considered "immediately called" by default
+}
+
+/** @phpstan-pure */
+function bug13288d()
+{
+	$exitingClosure = function () {
+		exit();
+	};
+	takesMaybeCallable2($exitingClosure);
+}
+
+/** @phpstan-pure */
+function takesMaybeCallable2(?\Closure $c) { // Closures are considered "immediately called"
+}
+
+/** @phpstan-pure */
+function bug13288e(MyClass $m)
+{
+	$exitingClosure = function () {
+		exit();
+	};
+	$m->takesMaybeCallable($exitingClosure);
+}
+
+class MyClass {
+	/** @phpstan-pure */
+	function takesMaybeCallable(?callable $c) { // arguments passed to methods are considered "later called" by default
+	}
 }