Fix invalidate static expressions in closures

Author: rajyan

src/Analyser/MutatingScope.php

@@ -2898,7 +2898,7 @@ private function enterAnonymousFunctionWithoutReflection(
 			$nativeTypes[$paramExprString] = ExpressionTypeHolder::createYes($use->var, $variableNativeType);
 		}
 
-		foreach ($this->expressionTypes as $exprString => $typeHolder) {
+		foreach ($this->invalidateStaticExpressions($this->expressionTypes) as $exprString => $typeHolder) {
 			$expr = $typeHolder->getExpr();
 			if ($expr instanceof Variable) {
 				continue;
@@ -2961,6 +2961,27 @@ private function expressionTypeIsUnchangeable(ExpressionTypeHolder $typeHolder):
 			&& (new ConstantBooleanType(true))->isSuperTypeOf($type)->yes();
 	}
 
+	/**
+	 * @param ExpressionTypeHolder[] $expressionTypes
+	 * @return ExpressionTypeHolder[]
+	 */
+	private function invalidateStaticExpressions(array $expressionTypes): array
+	{
+		$filteredExpressionTypes = [];
+		$nodeFinder = new NodeFinder();
+		foreach ($expressionTypes as $exprString => $expressionType) {
+			$staticExpression = $nodeFinder->findFirst(
+				[$expressionType->getExpr()],
+				static fn ($node) => $node instanceof Expr\StaticCall || $node instanceof Expr\StaticPropertyFetch,
+			);
+			if ($staticExpression !== null) {
+				continue;
+			}
+			$filteredExpressionTypes[$exprString] = $expressionType;
+		}
+		return $filteredExpressionTypes;
+	}
+
 	/**
 	 * @api
 	 * @param ParameterReflection[]|null $callableParameters
@@ -3037,7 +3058,7 @@ private function enterArrowFunctionWithoutReflection(Expr\ArrowFunction $arrowFu
 			$this->isDeclareStrictTypes(),
 			$arrowFunctionScope->getFunction(),
 			$arrowFunctionScope->getNamespace(),
-			$arrowFunctionScope->expressionTypes,
+			$this->invalidateStaticExpressions($arrowFunctionScope->expressionTypes),
 			$arrowFunctionScope->conditionalExpressions,
 			$arrowFunctionScope->inClosureBindScopeClass,
 			null,

tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php

@@ -35,4 +35,9 @@ public function testBug7913(): void
 		$this->analyse([__DIR__ . '/data/bug-7913.php'], []);
 	}
 
+	public function testBug8292(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-8292.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Arrays/data/bug-8292.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types = 1); // lint >= 7.4
+
+namespace Bug8292;
+
+class World{
+	public function addOnUnloadCallback(\Closure $c) : void{}
+}
+
+interface Compressor{}
+
+class ChunkCache
+{
+	/** @var self[][] */
+	private static array $instances = [];
+
+	/**
+	 * Fetches the ChunkCache instance for the given world. This lazily creates cache systems as needed.
+	 */
+	public static function getInstance(World $world, Compressor $compressor) : void{
+		$worldId = spl_object_id($world);
+		$compressorId = spl_object_id($compressor);
+		if(!isset(self::$instances[$worldId])){
+			self::$instances[$worldId] = [];
+			$world->addOnUnloadCallback(static function() use ($worldId) : void{
+				foreach(self::$instances[$worldId] as $cache){
+					$cache->caches = [];
+				}
+				unset(self::$instances[$worldId]);
+			});
+		}
+	}
+}

tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php

@@ -257,4 +257,9 @@ public function testBug6701(): void
 		]);
 	}
 
+	public function testStaticCallInFunctions(): void
+	{
+		$this->analyse([__DIR__ . '/data/static-call-in-functions.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Functions/data/static-call-in-functions.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace StaticCallsInFunctions;
+
+class HelloWorld
+{
+	/** @var \Closure[] */
+	private static $resolvers;
+
+	/** @return \Closure[] */
+	public static function getResolvers(): array
+	{
+		if (self::$resolvers === null) {
+			self::$resolvers = [
+				'a' => static function ($one, $two) {
+					return $one ?? $two;
+				},
+				'b' => static function ($one, $two, $three) {
+					return $one ?? $two ?? $three;
+				},
+			];
+
+			foreach (['c', 'd', 'e'] as $name) {
+				self::$resolvers[$name] = static function ($one, $two) {
+					return self::$resolvers['a']($one, $two);
+				};
+
+				self::$resolvers[$name] = static fn ($one, $two) => self::$resolvers['a']($one, $two);
+			}
+		}
+
+		return self::$resolvers;
+	}
+}