Fix forgetting static property access after impure call

src/Analyser/MutatingScope.php

@@ -4379,6 +4379,17 @@ private function shouldInvalidateExpression(string $exprStringToInvalidate, Expr
 		$nodeFinder = new NodeFinder();
 		$expressionToInvalidateClass = get_class($exprToInvalidate);
 		$found = $nodeFinder->findFirst([$expr], function (Node $node) use ($expressionToInvalidateClass, $exprStringToInvalidate): bool {
+			if (
+				$exprStringToInvalidate === '$this'
+				&& $node instanceof Name
+				&& (
+					in_array($node->toLowerString(), ['self', 'static', 'parent'], true)
+					|| ($this->getClassReflection() !== null && $this->getClassReflection()->is($this->resolveName($node)))
+				)
+			) {
+				return true;
+			}
+
 			if (!$node instanceof $expressionToInvalidateClass) {
 				return false;
 			}

src/Analyser/NodeScopeResolver.php

@@ -2597,6 +2597,13 @@ static function (): void {
 				$throwPoints[] = ThrowPoint::createImplicit($scope, $expr);
 			}
 
+			if (
+				$parametersAcceptor instanceof ClosureType && count($parametersAcceptor->getImpurePoints()) > 0
+				&& $scope->isInClass()
+			) {
+				$scope = $scope->invalidateExpression(new Variable('this'), true);
+			}
+
 			if (
 				$functionReflection !== null
 				&& in_array($functionReflection->getName(), ['json_encode', 'json_decode'], true)
@@ -3022,13 +3029,13 @@ static function (): void {
 
 			if (
 				$methodReflection !== null
-				&& !$methodReflection->isStatic()
 				&& (
 					$methodReflection->hasSideEffects()->yes()
-					|| $methodReflection->getName() === '__construct'
+					|| (
+						!$methodReflection->isStatic()
+						&& $methodReflection->getName() === '__construct'
+					)
 				)
-				&& $scopeFunction instanceof MethodReflection
-				&& !$scopeFunction->isStatic()
 				&& $scope->isInClass()
 				&& $scope->getClassReflection()->is($methodReflection->getDeclaringClass()->getName())
 			) {

tests/PHPStan/Analyser/nsrt/bug-12902-non-strict.php

@@ -72,8 +72,8 @@ public function __construct()
 		assertNativeType('int', self::$i);
 
 		$this->impureCall();
-		assertType('int', self::$i); // should be float|int
-		assertNativeType('int', self::$i); // should be float|int
+		assertType('float|int', self::$i);
+		assertNativeType('float|int', self::$i);
 	}
 
 	public function doFoo(): void {

tests/PHPStan/Analyser/nsrt/bug-12902.php

@@ -72,8 +72,8 @@ public function __construct()
 		assertNativeType('int', self::$i);
 
 		$this->impureCall();
-		assertType('int', self::$i); // should be float|int
-		assertNativeType('int', self::$i); // should be float|int
+		assertType('float|int', self::$i);
+		assertNativeType('float|int', self::$i);
 	}
 
 	public function doFoo(): void {
@@ -85,6 +85,33 @@ public function doFoo(): void {
 	public function impureCall(): void {}
 }
 
+class BaseClass
+{
+	static protected int|float $i;
+}
+
+class UsesBaseClass extends BaseClass
+{
+	public function __construct()
+	{
+		parent::$i = getInt();
+		assertType('int', parent::$i);
+		assertNativeType('int', parent::$i);
+
+		$this->impureCall();
+		assertType('float|int', parent::$i);
+		assertNativeType('float|int', parent::$i);
+	}
+
+	public function doFoo(): void {
+		assertType('float|int', parent::$i);
+		assertNativeType('float|int', parent::$i);
+	}
+
+	/** @phpstan-impure  */
+	public function impureCall(): void {}
+}
+
 function getInt(): int {
 	return 1;
 }

tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php

@@ -930,4 +930,9 @@ public function testBug12593(): void
 		$this->analyse([__DIR__ . '/data/bug-12593.php'], []);
 	}
 
+	public function testBug3747(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-3747.php'], []);
+	}
+
 }

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

@@ -0,0 +1,27 @@
+<?php
+
+namespace Bug3747;
+
+class X {
+
+	/** @var array<string,string> $x */
+	private static array $x;
+
+	public function y(): void {
+
+		self::$x = [];
+
+		$this->z();
+
+		echo self::$x['foo'];
+
+	}
+
+	private function z(): void {
+		self::$x['foo'] = 'bar';
+	}
+
+}
+
+$x = new X();
+$x->y();

tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php

@@ -173,4 +173,16 @@ public function testBug4912(): void
 		$this->analyse([__DIR__ . '/data/bug-4912.php'], []);
 	}
 
+	public function testBug4864(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-4864.php'], []);
+	}
+
+	public function testBug8926(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-8926.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php

@@ -1011,4 +1011,9 @@ public function testBug12748(): void
 		$this->analyse([__DIR__ . '/data/bug-12748.php'], []);
 	}
 
+	public function testBug11019(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-11019.php'], []);
+	}
+
 }

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

@@ -0,0 +1,21 @@
+<?php
+
+namespace Bug11019;
+
+class HelloWorld
+{
+	public static int $a;
+
+	public function reset(): void
+	{
+		static::$a = rand(1,10);
+	}
+
+	public function sayHello(): void
+	{
+		$this->reset();
+		assert(static::$a === 1);
+		$this->reset();
+		assert(static::$a === 1);
+	}
+}

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

@@ -0,0 +1,25 @@
+<?php
+
+namespace Bug4864;
+
+class Example
+{
+	/** @var mixed */
+	private $value;
+	private bool $isHandled;
+
+	public function fetchValue(callable $f): void
+	{
+		$this->isHandled = false;
+		$this->value = null;
+
+		(function () {
+			$this->isHandled = true;
+			$this->value = 'value';
+		})();
+
+		if ($this->isHandled) {
+			$f($this->value);
+		}
+	}
+}

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

@@ -0,0 +1,32 @@
+<?php
+
+namespace Bug8926;
+
+class Foo {
+	private bool $test;
+
+	/** @param int[] $arr */
+	function success(array $arr) : void {
+		$test = false;
+		(function($arr) use(&$test) {
+			$test = count($arr) == 1;
+		})($arr);
+
+		if ($test) {
+			echo "...\n";
+		}
+	}
+
+	/** @param int[] $arr */
+	function error(array $arr) : void {
+		$this->test = false;
+		(function($arr) {
+			$this->test = count($arr) == 1;
+		})($arr);
+
+
+		if ($this->test) {
+			echo "...\n";
+		}
+	}
+}

tests/PHPStan/Rules/Methods/NullsafeMethodCallRuleTest.php

@@ -55,4 +55,19 @@ public function testBug6922b(): void
 		$this->analyse([__DIR__ . '/data/bug-6922b.php'], []);
 	}
 
+	public function testBug8523(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-8523.php'], []);
+	}
+
+	public function testBug8523b(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-8523b.php'], []);
+	}
+
+	public function testBug8523c(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-8523c.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php

@@ -1232,4 +1232,18 @@ public function testBug1O580(): void
 		]);
 	}
 
+	public function testBug4443(): void
+	{
+		if (PHP_VERSION_ID < 80000) {
+			$this->markTestSkipped('Test requires PHP 8.0.');
+		}
+
+		$this->analyse([__DIR__ . '/data/bug-4443.php'], [
+			[
+				'Method Bug4443\HelloWorld::getArray() should return array<mixed> but returns array<mixed>|null.',
+				22,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Methods/data/bug-4443.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Bug4443;
+
+class HelloWorld
+{
+	/** @var array<mixed> */
+	private static ?array $arr = null;
+
+	private static function setup(): void
+	{
+		self::$arr = null;
+	}
+
+	/** @return array<mixed> */
+	public static function getArray(): array
+	{
+		if (self::$arr === null) {
+			self::$arr = [];
+			self::setup();
+		}
+		return self::$arr;
+	}
+}
+
+HelloWorld::getArray();

tests/PHPStan/Rules/Methods/data/bug-8523.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Bug8523;
+
+class HelloWorld
+{
+	public static ?HelloWorld $instance = null;
+
+	public static function bazz(): void
+	{
+		self::$instance = null;
+	}
+
+	public function foo(): void
+	{
+		self::$instance = new HelloWorld();
+
+		self::bazz();
+
+		self::$instance?->foo();
+	}
+
+	public function bar(): void
+	{
+		self::$instance = null;
+	}
+
+	public function baz(): void
+	{
+		self::$instance = new HelloWorld();
+
+		$this->bar();
+
+		self::$instance?->foo();
+	}
+}

tests/PHPStan/Rules/Methods/data/bug-8523b.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types = 1);
+
+namespace Bug8523b;
+
+class HelloWorld
+{
+	public static ?HelloWorld $instance = null;
+
+	public function save(): void {
+		self::$instance = new HelloWorld();
+
+		$callback = static function(): void {
+			self::$instance = null;
+		};
+
+		$callback();
+
+		var_dump(self::$instance);
+
+		self::$instance?->save();
+	}
+}
+
+(new HelloWorld())->save();