Forget narrowed properties after a possibly impure method call when its values are not remembered

src/Analyser/ExprHandler/MethodCallHandler.php

@@ -321,7 +321,19 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 				$throwPoints[] = $methodThrowPoint;
 			}
 
-			if ($methodReflection->getName() === '__construct' || $methodReflection->hasSideEffects()->yes()) {
+			$hasSideEffects = $methodReflection->hasSideEffects();
+			if (
+				$methodReflection->getName() === '__construct'
+				|| $hasSideEffects->yes()
+				// When possibly impure values are not remembered, a possibly impure method
+				// may also have changed the object's properties, so forget them too.
+				// Built-in methods are exempt, as they are from invalidating volatile expressions below.
+				|| (
+					!$this->rememberPossiblyImpureFunctionValues
+					&& !$hasSideEffects->no()
+					&& !$methodReflection->getDeclaringClass()->isBuiltin()
+				)
+			) {
 				$nodeScopeResolver->callNodeCallback($nodeCallback, new InvalidateExprNode($normalizedExpr->var), $scope, $storage);
 				$scope = $scope->invalidateExpression($normalizedExpr->var, true, $methodReflection->getDeclaringClass(), $methodReflection->isStatic());
 			}

src/Analyser/ExprHandler/StaticCallHandler.php

@@ -373,21 +373,30 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 			}
 		}
 
-		if (
-			$expr->class instanceof Name
-			&& $methodReflection !== null
-			&& (
+		if ($expr->class instanceof Name && $methodReflection !== null) {
+			$hasSideEffects = $methodReflection->hasSideEffects();
+			if (
 				(
-					!$methodReflection->isStatic()
-					&& $methodReflection->getName() === '__construct'
+					(
+						!$methodReflection->isStatic()
+						&& $methodReflection->getName() === '__construct'
+					)
+					|| $hasSideEffects->yes()
+					// When possibly impure values are not remembered, a possibly impure method
+					// may also have changed the object's properties, so forget them too.
+					// Built-in methods are exempt, as they are from invalidating volatile expressions below.
+					|| (
+						!$this->rememberPossiblyImpureFunctionValues
+						&& !$hasSideEffects->no()
+						&& !$methodReflection->getDeclaringClass()->isBuiltin()
+					)
 				)
-				|| $methodReflection->hasSideEffects()->yes()
-			)
-			&& $scope->isInClass()
-			&& $scope->getClassReflection()->is($methodReflection->getDeclaringClass()->getName())
-		) {
-			// a static method never receives $this, so property fetches on it survive
-			$scope = $scope->invalidateExpression(new Variable('this'), true, $methodReflection->getDeclaringClass(), $methodReflection->isStatic());
+				&& $scope->isInClass()
+				&& $scope->getClassReflection()->is($methodReflection->getDeclaringClass()->getName())
+			) {
+				// a static method never receives $this, so property fetches on it survive
+				$scope = $scope->invalidateExpression(new Variable('this'), true, $methodReflection->getDeclaringClass(), $methodReflection->isStatic());
+			}
 		}
 
 		if (

tests/PHPStan/Analyser/DoNotRememberPossiblyImpureFunctionValuesTest.php

@@ -11,6 +11,7 @@ class DoNotRememberPossiblyImpureFunctionValuesTest extends TypeInferenceTestCas
 	public static function dataAsserts(): iterable
 	{
 		yield from self::gatherAssertTypes(__DIR__ . '/data/do-not-remember-possibly-impure-function-values.php');
+		yield from self::gatherAssertTypes(__DIR__ . '/data/do-not-remember-possibly-impure-function-values-properties.php');
 	}
 
 	/**

tests/PHPStan/Analyser/data/do-not-remember-possibly-impure-function-values-properties.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace DoNotRememberPossiblyImpureFunctionValuesProperties;
+
+use function PHPStan\Testing\assertType;
+
+class StateMachine
+{
+
+	/** @var 'ready'|'done' */
+	public $state = 'ready';
+
+	/** @var 'ready'|'done' */
+	public static $staticState = 'ready';
+
+	public function advance(): bool
+	{
+		$this->state = 'done';
+		return true;
+	}
+
+	/** @phpstan-pure */
+	public function pure(): bool
+	{
+		return true;
+	}
+
+	/** @phpstan-impure */
+	public function impure(): bool
+	{
+		$this->state = 'done';
+		return true;
+	}
+
+	public static function advanceStatic(): bool
+	{
+		self::$staticState = 'done';
+		return true;
+	}
+
+	/** @phpstan-pure */
+	public static function pureStatic(): bool
+	{
+		return true;
+	}
+
+	public function doFoo(): void
+	{
+		$this->state = 'ready';
+		$this->advance();
+		assertType("'done'|'ready'", $this->state);
+
+		$this->state = 'ready';
+		if ($this->advance()) {
+			assertType("'done'|'ready'", $this->state);
+		}
+
+		$this->state = 'ready';
+		$this->pure();
+		assertType("'ready'", $this->state);
+
+		$this->state = 'ready';
+		$this->impure();
+		assertType("'done'|'ready'", $this->state);
+	}
+
+	public function doLocalVariable(): void
+	{
+		$state = 'ready';
+		$this->advance();
+		assertType("'ready'", $state);
+	}
+
+	public function doOtherObject(self $other): void
+	{
+		$this->state = 'ready';
+		$other->state = 'ready';
+		$other->advance();
+		assertType("'done'|'ready'", $other->state);
+		assertType("'ready'", $this->state);
+	}
+
+	public function doNullsafe(?self $other): void
+	{
+		if ($other === null) {
+			return;
+		}
+
+		$other->state = 'ready';
+		$other?->advance();
+		assertType("'done'|'ready'", $other->state);
+	}
+
+	public function doStatic(): void
+	{
+		self::$staticState = 'ready';
+		self::advanceStatic();
+		assertType("'done'|'ready'", self::$staticState);
+
+		self::$staticState = 'ready';
+		static::advanceStatic();
+		assertType("'done'|'ready'", self::$staticState);
+
+		self::$staticState = 'ready';
+		self::pureStatic();
+		assertType("'ready'", self::$staticState);
+	}
+
+	public function doStaticKeepsInstanceProperties(): void
+	{
+		$this->state = 'ready';
+		self::advanceStatic();
+		assertType("'ready'", $this->state);
+	}
+
+	public static function doStaticFromStaticMethod(): void
+	{
+		self::$staticState = 'ready';
+		self::advanceStatic();
+		assertType("'done'|'ready'", self::$staticState);
+
+		self::$staticState = 'ready';
+		self::pureStatic();
+		assertType("'ready'", self::$staticState);
+	}
+
+}
+
+class Holder
+{
+
+	public ?\stdClass $foo = null;
+
+	/** @phpstan-assert-if-true !null $this->foo */
+	public function hasFoo(): bool
+	{
+		return $this->foo !== null;
+	}
+
+	public function doAssertIfTrue(): void
+	{
+		if ($this->hasFoo()) {
+			assertType('stdClass', $this->foo);
+		}
+	}
+
+}
+
+/** @extends \ArrayObject<int, int> */
+class Bag extends \ArrayObject
+{
+
+	public ?int $n = null;
+
+	public function doBuiltinMethod(): void
+	{
+		$this->n = 1;
+		$this->count();
+		$this->getIterator();
+		assertType('1', $this->n);
+	}
+
+}
+
+class ChildStateMachine extends StateMachine
+{
+
+	public function advance(): bool
+	{
+		$this->state = 'ready';
+		parent::advance();
+		assertType("'done'|'ready'", $this->state);
+
+		return true;
+	}
+
+}