Allow wider set hook parameter type when assigning properties outside of their hooks

Author: ondrejmirtes

src/Reflection/Php/PhpPropertyReflection.php

@@ -103,6 +103,14 @@ public function getReadableType(): Type
 
 	public function getWritableType(): Type
 	{
+		if ($this->hasHook('set')) {
+			$setHookVariant = $this->getHook('set')->getOnlyVariant();
+			$parameters = $setHookVariant->getParameters();
+			if (isset($parameters[0])) {
+				return $parameters[0]->getType();
+			}
+		}
+
 		return $this->getReadableType();
 	}
 

src/Rules/Properties/TypesAssignedToPropertiesRule.php

@@ -3,15 +3,19 @@
 namespace PHPStan\Rules\Properties;
 
 use PhpParser\Node;
+use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Expr\StaticPropertyFetch;
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\PropertyAssignNode;
+use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;
 use PHPStan\Reflection\PropertyReflection;
 use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\VerbosityLevel;
 use function array_merge;
+use function is_string;
 use function sprintf;
 
 /**
@@ -34,12 +38,14 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		$propertyReflections = $this->propertyReflectionFinder->findPropertyReflectionsFromNode($node->getPropertyFetch(), $scope);
+		$propertyFetch = $node->getPropertyFetch();
+		$propertyReflections = $this->propertyReflectionFinder->findPropertyReflectionsFromNode($propertyFetch, $scope);
 
 		$errors = [];
 		foreach ($propertyReflections as $propertyReflection) {
 			$errors = array_merge($errors, $this->processSingleProperty(
 				$propertyReflection,
+				$propertyFetch,
 				$node->getAssignedExpr(),
 			));
 		}
@@ -52,15 +58,31 @@ public function processNode(Node $node, Scope $scope): array
 	 */
 	private function processSingleProperty(
 		FoundPropertyReflection $propertyReflection,
+		PropertyFetch|StaticPropertyFetch $fetch,
 		Node\Expr $assignedExpr,
 	): array
 	{
 		if (!$propertyReflection->isWritable()) {
 			return [];
 		}
 
-		$propertyType = $propertyReflection->getWritableType();
 		$scope = $propertyReflection->getScope();
+		$inFunction = $scope->getFunction();
+		if (
+			$fetch instanceof PropertyFetch
+			&& $fetch->var instanceof Node\Expr\Variable
+			&& is_string($fetch->var->name)
+			&& $fetch->var->name === 'this'
+			&& $fetch->name instanceof Node\Identifier
+			&& $inFunction instanceof PhpMethodFromParserNodeReflection
+			&& $inFunction->isPropertyHook()
+			&& $inFunction->getHookedPropertyName() === $fetch->name->toString()
+		) {
+			$propertyType = $propertyReflection->getReadableType();
+		} else {
+			$propertyType = $propertyReflection->getWritableType();
+		}
+
 		$assignedValueType = $scope->getType($assignedExpr);
 
 		$accepts = $this->ruleLevelHelper->accepts($propertyType, $assignedValueType, $scope->isDeclareStrictTypes());

tests/PHPStan/Rules/Properties/TypesAssignedToPropertiesRuleTest.php

@@ -722,4 +722,26 @@ public function testShortBodySetHook(): void
 		]);
 	}
 
+	public function testPropertyHooks(): void
+	{
+		if (PHP_VERSION_ID < 80400) {
+			$this->markTestSkipped('Test requires PHP 8.4.');
+		}
+
+		$this->analyse([__DIR__ . '/data/assign-hooked-properties.php'], [
+			[
+				'Property AssignHookedProperties\Foo::$i (int) does not accept array<string>|int.',
+				11,
+			],
+			[
+				'Property AssignHookedProperties\Foo::$j (int) does not accept array<string>|int.',
+				19,
+			],
+			[
+				'Property AssignHookedProperties\Foo::$i (array<string>|int) does not accept array<int, int>.',
+				27,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Properties/data/assign-hooked-properties.php

@@ -0,0 +1,30 @@
+<?php // lint >= 8.4
+
+namespace AssignHookedProperties;
+
+class Foo
+{
+
+	public int $i {
+		/** @param array<string>|int $val */
+		set (array|int $val) {
+			$this->i = $val; // only int allowed
+		}
+	}
+
+	public int $j {
+		/** @param array<string>|int $val */
+		set (array|int $val) {
+			$this->i = $val; // this is okay - hook called
+			$this->j = $val; // only int allowed
+		}
+	}
+
+	public function doFoo(): void
+	{
+		$this->i = ['foo']; // okay
+		$this->i = 1; // okay
+		$this->i = [1]; // not okay
+	}
+
+}