Invalidate static expressions when a non-static expression is called

Author: takaram

src/Analyser/MutatingScope.php

@@ -3643,6 +3643,67 @@ private function invalidateMethodsOnExpression(Expr $expressionToInvalidate): se
 		);
 	}
 
+	public function invalidateStaticMembers(string $className): self
+	{
+		if (!$this->reflectionProvider->hasClass($className)) {
+			return $this;
+		}
+
+		$classReflection = $this->reflectionProvider->getClass($className);
+		$classNamesToInvalidate = [strtolower($className)];
+		foreach ($classReflection->getParents() as $parentClass) {
+			$classNamesToInvalidate[] = strtolower($parentClass->getName());
+		}
+
+		$expressionTypes = $this->expressionTypes;
+		$nativeExpressionTypes = $this->nativeExpressionTypes;
+		$invalidated = false;
+		$nodeFinder = new NodeFinder();
+		foreach ($expressionTypes as $exprString => $exprTypeHolder) {
+			$expr = $exprTypeHolder->getExpr();
+			$found = $nodeFinder->findFirst([$expr], static function (Node $node) use ($classNamesToInvalidate): bool {
+				if (!$node instanceof Expr\StaticCall && !$node instanceof Expr\StaticPropertyFetch) {
+					return false;
+				}
+				if (!$node->class instanceof Name || !$node->class->isFullyQualified()) {
+					return false;
+				}
+
+				return in_array($node->class->toLowerString(), $classNamesToInvalidate, true);
+			});
+			if ($found === null) {
+				continue;
+			}
+
+			unset($expressionTypes[$exprString]);
+			unset($nativeExpressionTypes[$exprString]);
+			$invalidated = true;
+		}
+
+		if (!$invalidated) {
+			return $this;
+		}
+
+		return $this->scopeFactory->create(
+			$this->context,
+			$this->isDeclareStrictTypes(),
+			$this->getFunction(),
+			$this->getNamespace(),
+			$expressionTypes,
+			$nativeExpressionTypes,
+			$this->conditionalExpressions,
+			$this->inClosureBindScopeClasses,
+			$this->anonymousFunctionReflection,
+			$this->inFirstLevelStatement,
+			$this->currentlyAssignedExpressions,
+			$this->currentlyAllowedUndefinedExpressions,
+			[],
+			$this->afterExtractCall,
+			$this->parentScope,
+			$this->nativeTypesPromoted,
+		);
+	}
+
 	private function setExpressionCertainty(Expr $expr, TrinaryLogic $certainty): self
 	{
 		if ($this->hasExpressionType($expr)->no()) {

src/Analyser/NodeScopeResolver.php

@@ -3213,9 +3213,16 @@ function (MutatingScope $scope) use ($stmt, $expr, $nodeCallback, $context, $sto
 			$scope = $result->getScope();
 
 			if ($methodReflection !== null) {
-				if ($methodReflection->getName() === '__construct' || $methodReflection->hasSideEffects()->yes()) {
+				$hasSideEffects = $methodReflection->hasSideEffects()->yes();
+				if ($hasSideEffects || $methodReflection->getName() === '__construct') {
 					$this->callNodeCallback($nodeCallback, new InvalidateExprNode($normalizedExpr->var), $scope, $storage);
 					$scope = $scope->invalidateExpression($normalizedExpr->var, true, $methodReflection->getDeclaringClass());
+					if ($hasSideEffects) {
+						$classNames = $scope->getType($normalizedExpr->var)->getObjectClassNames();
+						foreach ($classNames as $className) {
+							$scope = $scope->invalidateStaticMembers($className);
+						}
+					}
 				}
 				if ($parametersAcceptor !== null && !$methodReflection->isStatic()) {
 					$selfOutType = $methodReflection->getSelfOutType();

tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php

@@ -1056,4 +1056,9 @@ public function testBug11609(): void
 		]);
 	}
 
+	public function testBug13416(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-13416.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Comparison/data/bug-13416.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types=1);
+
+namespace Bug13416;
+
+class MyRecord {
+	/** @var array<int, self> */
+	private static array $storage = [];
+
+	/** @phpstan-impure */
+	public function insert(): void {
+		self::$storage[] = $this;
+	}
+
+	/**
+	 * @return array<int, self>
+	 * @phpstan-impure
+	 */
+	public static function find(): array {
+		return self::$storage;
+	}
+}
+
+class AnotherRecord extends MyRecord {}
+
+class PHPStanMinimalBug {
+	public function testMinimalBug(): void {
+		$msg1 = new MyRecord();
+		$msg1->insert();
+
+		assert(
+			count(MyRecord::find()) === 1,
+			'should have 1 record initially'
+		);
+
+		$msg2 = new MyRecord();
+		$msg2->insert();
+
+		assert(
+			count(MyRecord::find()) === 2,
+			'should have 2 messages after adding one'
+		);
+	}
+
+	public function testMinimalBugChildClass(): void {
+		$msg1 = new AnotherRecord();
+		$msg1->insert();
+
+		assert(
+			count(MyRecord::find()) === 1,
+			'should have 1 record initially'
+		);
+
+		$msg2 = new AnotherRecord();
+		$msg2->insert();
+
+		assert(
+			count(MyRecord::find()) === 2,
+			'should have 2 messages after adding one'
+		);
+	}
+}