Evaluate uninitialized properties based on each execution end in cons…

…tructor

Closes phpstan/phpstan#7649

src/Analyser/NodeScopeResolver.php

@@ -691,7 +691,7 @@ private function processStmtNode(
 			$this->processAttributeGroups($stmt->attrGroups, $classScope, $classStatementsGatherer);
 
 			$this->processStmtNodes($stmt, $stmt->stmts, $classScope, $classStatementsGatherer, $context);
-			$nodeCallback(new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensionProvider, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls()), $classScope);
+			$nodeCallback(new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensionProvider, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes()), $classScope);
 			$nodeCallback(new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls()), $classScope);
 			$nodeCallback(new ClassConstantsNode($stmt, $classStatementsGatherer->getConstants(), $classStatementsGatherer->getConstantFetches()), $classScope);
 			$classReflection->evictPrivateSymbols();
@@ -3814,6 +3814,9 @@ private function processAssignVar(
 				} else {
 					if ($var instanceof PropertyFetch || $var instanceof StaticPropertyFetch) {
 						$nodeCallback(new PropertyAssignNode($var, $assignedPropertyExpr, $isAssignOp), $scope);
+						if ($var instanceof PropertyFetch && $var->name instanceof Node\Identifier && !$isAssignOp) {
+							$scope = $scope->assignInitializedProperty($scope->getType($var->var), $var->name->toString());
+						}
 					}
 					$scope = $scope->assignExpression(
 						$var,
@@ -3835,6 +3838,9 @@ private function processAssignVar(
 			} else {
 				if ($var instanceof PropertyFetch || $var instanceof StaticPropertyFetch) {
 					$nodeCallback(new PropertyAssignNode($var, $assignedPropertyExpr, $isAssignOp), $scope);
+					if ($var instanceof PropertyFetch && $var->name instanceof Node\Identifier && !$isAssignOp) {
+						$scope = $scope->assignInitializedProperty($scope->getType($var->var), $var->name->toString());
+					}
 				}
 			}
 

src/Node/ClassPropertiesNode.php

@@ -21,10 +21,12 @@
 use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
+use PHPStan\Type\NeverType;
 use PHPStan\Type\TypeUtils;
 use function array_key_exists;
 use function array_keys;
 use function in_array;
+use function strtolower;
 
 /** @api */
 class ClassPropertiesNode extends NodeAbstract implements VirtualNode
@@ -34,13 +36,15 @@ class ClassPropertiesNode extends NodeAbstract implements VirtualNode
 	 * @param ClassPropertyNode[] $properties
 	 * @param array<int, PropertyRead|PropertyWrite> $propertyUsages
 	 * @param array<int, MethodCall> $methodCalls
+	 * @param array<string, MethodReturnStatementsNode> $returnStatementNodes
 	 */
 	public function __construct(
 		private ClassLike $class,
 		private ReadWritePropertiesExtensionProvider $readWritePropertiesExtensionProvider,
 		private array $properties,
 		private array $propertyUsages,
 		private array $methodCalls,
+		private array $returnStatementNodes,
 	)
 	{
 		parent::__construct($class->getAttributes());
@@ -191,10 +195,6 @@ public function getUninitializedProperties(
 			}
 
 			if ($usage instanceof PropertyWrite) {
-				if (array_key_exists($propertyName, $uninitializedProperties)) {
-					unset($uninitializedProperties[$propertyName]);
-				}
-
 				if (array_key_exists($propertyName, $initializedPropertiesMap)) {
 					$hasInitialization = $initializedPropertiesMap[$propertyName]->or($usageScope->hasExpressionType(new PropertyInitializationExpr($propertyName)));
 					if (!$hasInitialization->no() && !$usage->isPromotedPropertyWrite()) {
@@ -217,6 +217,57 @@ public function getUninitializedProperties(
 			}
 		}
 
+		foreach (array_keys($methodsCalledFromConstructor) as $constructor) {
+			$lowerConstructorName = strtolower($constructor);
+			if (!array_key_exists($lowerConstructorName, $this->returnStatementNodes)) {
+				continue;
+			}
+
+			$returnStatementsNode = $this->returnStatementNodes[$lowerConstructorName];
+			$methodScope = null;
+			foreach ($returnStatementsNode->getExecutionEnds() as $executionEnd) {
+				$statementResult = $executionEnd->getStatementResult();
+				$endNode = $executionEnd->getNode();
+				if ($statementResult->isAlwaysTerminating()) {
+					if ($endNode instanceof Node\Stmt\Throw_) {
+						continue;
+					}
+					if ($endNode instanceof Node\Stmt\Expression) {
+						$exprType = $statementResult->getScope()->getType($endNode->expr);
+						if ($exprType instanceof NeverType && $exprType->isExplicit()) {
+							continue;
+						}
+					}
+				}
+				if ($methodScope === null) {
+					$methodScope = $statementResult->getScope();
+					continue;
+				}
+
+				$methodScope = $methodScope->mergeWith($statementResult->getScope());
+			}
+
+			foreach ($returnStatementsNode->getReturnStatements() as $returnStatement) {
+				if ($methodScope === null) {
+					$methodScope = $returnStatement->getScope();
+					continue;
+				}
+				$methodScope = $methodScope->mergeWith($returnStatement->getScope());
+			}
+
+			if ($methodScope === null) {
+				continue;
+			}
+
+			foreach (array_keys($uninitializedProperties) as $propertyName) {
+				if (!$methodScope->hasExpressionType(new PropertyInitializationExpr($propertyName))->yes()) {
+					continue;
+				}
+
+				unset($uninitializedProperties[$propertyName]);
+			}
+		}
+
 		return [
 			$uninitializedProperties,
 			$prematureAccess,

src/Node/ClassStatementsGatherer.php

@@ -20,6 +20,7 @@
 use PHPStan\Type\TypeUtils;
 use function count;
 use function in_array;
+use function strtolower;
 
 class ClassStatementsGatherer
 {
@@ -50,6 +51,9 @@ class ClassStatementsGatherer
 	/** @var ClassConstantFetch[] */
 	private array $constantFetches = [];
 
+	/** @var array<string, MethodReturnStatementsNode> */
+	private array $returnStatementNodes = [];
+
 	/**
 	 * @param callable(Node $node, Scope $scope): void $nodeCallback
 	 */
@@ -109,6 +113,14 @@ public function getConstantFetches(): array
 		return $this->constantFetches;
 	}
 
+	/**
+	 * @return array<string, MethodReturnStatementsNode>
+	 */
+	public function getReturnStatementsNodes(): array
+	{
+		return $this->returnStatementNodes;
+	}
+
 	public function __invoke(Node $node, Scope $scope): void
 	{
 		$nodeCallback = $this->nodeCallback;
@@ -151,6 +163,10 @@ private function gatherNodes(Node $node, Scope $scope): void
 			$this->methodCalls[] = new \PHPStan\Node\Method\MethodCall($node->getOriginalNode(), $scope);
 			return;
 		}
+		if ($node instanceof MethodReturnStatementsNode) {
+			$this->returnStatementNodes[strtolower($node->getMethodName())] = $node;
+			return;
+		}
 		if (
 			$node instanceof Expr\FuncCall
 			&& $node->name instanceof Node\Name

src/Node/MethodReturnStatementsNode.php

@@ -57,6 +57,11 @@ public function hasNativeReturnTypehint(): bool
 		return $this->classMethod->returnType !== null;
 	}
 
+	public function getMethodName(): string
+	{
+		return $this->classMethod->name->toString();
+	}
+
 	public function getYieldStatements(): array
 	{
 		return $this->yieldStatements;

tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php

@@ -84,6 +84,10 @@ public function testRule(): void
 				'Class MissingReadOnlyPropertyAssignPhpDoc\BarDoubleAssignInSetter has an uninitialized @readonly property $foo. Assign it in the constructor.',
 				57,
 			],
+			[
+				'Class MissingReadOnlyPropertyAssignPhpDoc\AssignOp has an uninitialized @readonly property $foo. Assign it in the constructor.',
+				85,
+			],
 			[
 				'Access to an uninitialized @readonly property MissingReadOnlyPropertyAssignPhpDoc\AssignOp::$foo.',
 				92,

tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php

@@ -84,6 +84,10 @@ public function testRule(): void
 				'Class MissingReadOnlyPropertyAssign\BarDoubleAssignInSetter has an uninitialized readonly property $foo. Assign it in the constructor.',
 				53,
 			],
+			[
+				'Class MissingReadOnlyPropertyAssign\AssignOp has an uninitialized readonly property $foo. Assign it in the constructor.',
+				79,
+			],
 			[
 				'Access to an uninitialized readonly property MissingReadOnlyPropertyAssign\AssignOp::$foo.',
 				85,
@@ -195,4 +199,18 @@ public function testBug7198(): void
 		$this->analyse([__DIR__ . '/data/bug-7198.php'], []);
 	}
 
+	public function testBug7649(): void
+	{
+		if (PHP_VERSION_ID < 80100) {
+			$this->markTestSkipped('Test requires PHP 8.1.');
+		}
+
+		$this->analyse([__DIR__ . '/data/bug-7649.php'], [
+			[
+				'Class Bug7649\Foo has an uninitialized readonly property $bar. Assign it in the constructor.',
+				7,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php

@@ -91,10 +91,18 @@ public function testRule(): void
 				'Access to an uninitialized property UninitializedProperty\InitializedInPublicSetterNonFinalClass::$foo.',
 				278,
 			],*/
+			[
+				'Class UninitializedProperty\SometimesInitializedInPrivateSetter has an uninitialized property $foo. Give it default value or assign it in the constructor.',
+				286,
+			],
 			[
 				'Access to an uninitialized property UninitializedProperty\SometimesInitializedInPrivateSetter::$foo.',
 				303,
 			],
+			[
+				'Class UninitializedProperty\EarlyReturn has an uninitialized property $foo. Give it default value or assign it in the constructor.',
+				372,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Properties/data/bug-7649.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Bug7649;
+
+class Foo
+{
+	public readonly string $bar;
+
+	public function __construct(bool $flag)
+	{
+		if ($flag) {
+			$this->bar = 'baz';
+		} else {
+		}
+	}
+}

tests/PHPStan/Rules/Properties/data/uninitialized-property.php

@@ -332,3 +332,77 @@ public function doSomething()
 	}
 
 }
+
+class ThrowInConstructor1
+{
+
+	private int $foo;
+
+	public function __construct()
+	{
+		if (rand(0, 1)) {
+			$this->foo = 1;
+			return;
+		}
+
+		throw new \Exception;
+	}
+
+}
+
+class ThrowInConstructor2
+{
+
+	private int $foo;
+
+	public function __construct()
+	{
+		if (rand(0, 1)) {
+			throw new \Exception;
+		}
+
+		$this->foo = 1;
+	}
+
+}
+
+class EarlyReturn
+{
+
+	private int $foo;
+
+	public function __construct()
+	{
+		if (rand(0, 1)) {
+			return;
+		}
+
+		$this->foo = 1;
+	}
+
+}
+
+class NeverInConstructor
+{
+
+	private int $foo;
+
+	public function __construct()
+	{
+		if (rand(0, 1)) {
+			$this->foo = 1;
+			return;
+		}
+
+		$this->returnNever();
+	}
+
+	/**
+	 * @return never
+	 */
+	private function returnNever()
+	{
+		throw new \Exception();
+	}
+
+}