IncompatiblePropertyHookPhpDocTypeRule - level 2

Author: ondrejmirtes

conf/config.level2.neon

@@ -52,6 +52,7 @@ rules:
 	- PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule
 	- PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule
 	- PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule
+	- PHPStan\Rules\PhpDoc\IncompatiblePropertyHookPhpDocTypeRule
 	- PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule
 	- PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule
 	- PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule

src/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRule.php

@@ -0,0 +1,85 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PhpDoc;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\InPropertyHookNode;
+use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;
+use PHPStan\Rules\Rule;
+use PHPStan\Type\FileTypeMapper;
+use PHPStan\Type\Type;
+
+/**
+ * @implements Rule<InPropertyHookNode>
+ */
+final class IncompatiblePropertyHookPhpDocTypeRule implements Rule
+{
+
+	public function __construct(
+		private FileTypeMapper $fileTypeMapper,
+		private IncompatiblePhpDocTypeCheck $check,
+	)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return InPropertyHookNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$docComment = $node->getDocComment();
+		if ($docComment === null) {
+			return [];
+		}
+
+		$hookReflection = $node->getHookReflection();
+
+		$resolvedPhpDoc = $this->fileTypeMapper->getResolvedPhpDoc(
+			$scope->getFile(),
+			$node->getClassReflection()->getName(),
+			$scope->isInTrait() ? $scope->getTraitReflection()->getName() : null,
+			$hookReflection->getName(),
+			$docComment->getText(),
+		);
+
+		return $this->check->check(
+			$scope,
+			$node,
+			$resolvedPhpDoc,
+			$hookReflection->getName(),
+			$this->getNativeParameterTypes($hookReflection),
+			$this->getByRefParameters($hookReflection),
+			$hookReflection->getNativeReturnType(),
+		);
+	}
+
+	/**
+	 * @return array<string, Type>
+	 */
+	private function getNativeParameterTypes(PhpMethodFromParserNodeReflection $node): array
+	{
+		$parameters = [];
+		foreach ($node->getParameters() as $parameter) {
+			$parameters[$parameter->getName()] = $parameter->getNativeType();
+		}
+
+		return $parameters;
+	}
+
+	/**
+	 * @return array<string, false>
+	 */
+	private function getByRefParameters(PhpMethodFromParserNodeReflection $node): array
+	{
+		$parameters = [];
+		foreach ($node->getParameters() as $parameter) {
+			$parameters[$parameter->getName()] = false;
+		}
+
+		return $parameters;
+	}
+
+}

tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php

@@ -0,0 +1,84 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PhpDoc;
+
+use PHPStan\Rules\ClassCaseSensitivityCheck;
+use PHPStan\Rules\ClassForbiddenNameCheck;
+use PHPStan\Rules\ClassNameCheck;
+use PHPStan\Rules\Generics\GenericObjectTypeCheck;
+use PHPStan\Rules\Generics\TemplateTypeCheck;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
+
+/**
+ * @extends RuleTestCase<IncompatiblePropertyHookPhpDocTypeRule>
+ */
+class IncompatiblePropertyHookPhpDocTypeRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		$reflectionProvider = $this->createReflectionProvider();
+		$typeAliasResolver = $this->createTypeAliasResolver([], $reflectionProvider);
+
+		return new IncompatiblePropertyHookPhpDocTypeRule(
+			self::getContainer()->getByType(FileTypeMapper::class),
+			new IncompatiblePhpDocTypeCheck(
+				new GenericObjectTypeCheck(),
+				new UnresolvableTypeHelper(),
+				new GenericCallableRuleHelper(
+					new TemplateTypeCheck(
+						$reflectionProvider,
+						new ClassNameCheck(
+							new ClassCaseSensitivityCheck($reflectionProvider, true),
+							new ClassForbiddenNameCheck(self::getContainer()),
+						),
+						new GenericObjectTypeCheck(),
+						$typeAliasResolver,
+						true,
+					),
+				),
+			),
+		);
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/incompatible-property-hook-phpdoc-types.php'], [
+			[
+				'PHPDoc tag @return with type string is incompatible with native type int.',
+				10,
+			],
+			[
+				'PHPDoc tag @return with type string is incompatible with native type void.',
+				17,
+			],
+			[
+				'PHPDoc tag @param for parameter $value with type string is incompatible with native type int.',
+				27,
+			],
+			[
+				'Parameter $value for PHPDoc tag @param-out is not passed by reference.',
+				27,
+			],
+			[
+				'PHPDoc tag @param for parameter $value contains unresolvable type.',
+				34,
+			],
+			[
+				'PHPDoc tag @param for parameter $value contains generic type Exception<int> but class Exception is not generic.',
+				41,
+			],
+			[
+				'PHPDoc tag @param for parameter $value template T of callable<T of mixed>(T): T shadows @template T for class IncompatiblePropertyHookPhpDocTypes\GenericFoo.',
+				54,
+			],
+			[
+				'PHPDoc tag @param for parameter $value template of callable<\stdClass of mixed>(T): T cannot have existing class \stdClass as its name.',
+				61,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/PhpDoc/data/incompatible-property-hook-phpdoc-types.php

@@ -0,0 +1,66 @@
+<?php // lint >= 8.4
+
+namespace IncompatiblePropertyHookPhpDocTypes;
+
+class Foo
+{
+
+	public int $i {
+		/** @return string */
+		get {
+			return $this->i;
+		}
+	}
+
+	public int $j {
+		/** @return string */
+		set {
+			$this->j = 1;
+		}
+	}
+
+	public int $k {
+		/**
+		 * @param string $value
+		 * @param-out int $value
+		 */
+		set {
+			$this->k = 1;
+		}
+	}
+
+	public int $l {
+		/** @param \stdClass&\Exception $value */
+		set {
+
+		}
+	}
+
+	public \Exception $m {
+		/** @param \Exception<int> $value */
+		set {
+
+		}
+	}
+
+}
+
+/** @template T */
+class GenericFoo
+{
+
+	public int $n {
+		/** @param int|callable<T>(T): T $value */
+		set (int|callable $value) {
+
+		}
+	}
+
+	public int $o {
+		/** @param int|callable<\stdClass>(T): T $value */
+		set (int|callable $value) {
+
+		}
+	}
+
+}