TooWidePropertyHookThrowTypeRule - level 4

Author: ondrejmirtes

conf/config.level4.neon

@@ -31,6 +31,8 @@ conditionalTags:
 		phpstan.rules.rule: %exceptions.check.tooWideThrowType%
 	PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule:
 		phpstan.rules.rule: %exceptions.check.tooWideThrowType%
+	PHPStan\Rules\Exceptions\TooWidePropertyHookThrowTypeRule:
+		phpstan.rules.rule: %exceptions.check.tooWideThrowType%
 
 parameters:
 	checkAdvancedIsset: true
@@ -241,6 +243,9 @@ services:
 	-
 		class: PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule
 
+	-
+		class: PHPStan\Rules\Exceptions\TooWidePropertyHookThrowTypeRule
+
 	-
 		class: PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule
 		arguments:

src/Rules/Exceptions/TooWidePropertyHookThrowTypeRule.php

@@ -0,0 +1,74 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Exceptions;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\PropertyHookReturnStatementsNode;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\FileTypeMapper;
+use function sprintf;
+use function ucfirst;
+
+/**
+ * @implements Rule<PropertyHookReturnStatementsNode>
+ */
+final class TooWidePropertyHookThrowTypeRule implements Rule
+{
+
+	public function __construct(private FileTypeMapper $fileTypeMapper, private TooWideThrowTypeCheck $check)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return PropertyHookReturnStatementsNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$docComment = $node->getDocComment();
+		if ($docComment === null) {
+			return [];
+		}
+
+		$statementResult = $node->getStatementResult();
+		$hookReflection = $node->getHookReflection();
+		if ($hookReflection->getPropertyHookName() === null) {
+			throw new ShouldNotHappenException();
+		}
+
+		$classReflection = $node->getClassReflection();
+		$resolvedPhpDoc = $this->fileTypeMapper->getResolvedPhpDoc(
+			$scope->getFile(),
+			$classReflection->getName(),
+			$scope->isInTrait() ? $scope->getTraitReflection()->getName() : null,
+			$hookReflection->getName(),
+			$docComment->getText(),
+		);
+
+		if ($resolvedPhpDoc->getThrowsTag() === null) {
+			return [];
+		}
+
+		$throwType = $resolvedPhpDoc->getThrowsTag()->getType();
+
+		$errors = [];
+		foreach ($this->check->check($throwType, $statementResult->getThrowPoints()) as $throwClass) {
+			$errors[] = RuleErrorBuilder::message(sprintf(
+				'%s hook for property %s::$%s has %s in PHPDoc @throws tag but it\'s not thrown.',
+				ucfirst($hookReflection->getPropertyHookName()),
+				$hookReflection->getDeclaringClass()->getDisplayName(),
+				$hookReflection->getHookedPropertyName(),
+				$throwClass,
+			))
+				->identifier('throws.unusedType')
+				->build();
+		}
+
+		return $errors;
+	}
+
+}

tests/PHPStan/Rules/Exceptions/TooWidePropertyHookThrowTypeRuleTest.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Exceptions;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
+use const PHP_VERSION_ID;
+
+/**
+ * @extends RuleTestCase<TooWidePropertyHookThrowTypeRule>
+ */
+class TooWidePropertyHookThrowTypeRuleTest extends RuleTestCase
+{
+
+	private bool $implicitThrows = true;
+
+	protected function getRule(): Rule
+	{
+		return new TooWidePropertyHookThrowTypeRule(self::getContainer()->getByType(FileTypeMapper::class), new TooWideThrowTypeCheck($this->implicitThrows));
+	}
+
+	public function testRule(): void
+	{
+		if (PHP_VERSION_ID < 80400) {
+			$this->markTestSkipped('Test requires PHP 8.4.');
+		}
+
+		$this->analyse([__DIR__ . '/data/too-wide-throws-property-hook.php'], [
+			[
+				'Get hook for property TooWideThrowsPropertyHook\Foo::$d has DomainException in PHPDoc @throws tag but it\'s not thrown.',
+				33,
+			],
+			[
+				'Get hook for property TooWideThrowsPropertyHook\Foo::$g has DomainException in PHPDoc @throws tag but it\'s not thrown.',
+				58,
+			],
+			[
+				'Get hook for property TooWideThrowsPropertyHook\Foo::$h has DomainException in PHPDoc @throws tag but it\'s not thrown.',
+				68,
+			],
+			[
+				'Get hook for property TooWideThrowsPropertyHook\Foo::$j has DomainException in PHPDoc @throws tag but it\'s not thrown.',
+				76,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/Exceptions/data/too-wide-throws-property-hook.php

@@ -0,0 +1,81 @@
+<?php // lint >= 8.4
+
+namespace TooWideThrowsPropertyHook;
+
+use DomainException;
+
+class Foo
+{
+
+	public int $a {
+		/** @throws \InvalidArgumentException */
+		get {
+			throw new \InvalidArgumentException();
+		}
+	}
+
+	public int $b {
+		/** @throws \LogicException */
+		get {
+			throw new \InvalidArgumentException();
+		}
+	}
+
+	public int $c {
+		/** @throws \InvalidArgumentException */
+		get {
+			throw new \LogicException();
+		}
+	}
+
+	public int $d {
+		/** @throws \InvalidArgumentException|\DomainException */
+		get { // error - DomainException unused
+			throw new \InvalidArgumentException();
+		}
+	}
+
+	public int $e {
+		/** @throws void */
+		get { // ok - picked up by different rule
+			throw new \InvalidArgumentException();
+		}
+	}
+
+	public int $f {
+		/** @throws \InvalidArgumentException|\DomainException */
+		get {
+			if (rand(0, 1)) {
+				throw new \InvalidArgumentException();
+			}
+
+			throw new DomainException();
+		}
+	}
+
+	public int $g {
+		/** @throws \DomainException */
+		get { // error - DomainException unused
+			throw new \InvalidArgumentException();
+		}
+	}
+
+	public int $h {
+		/**
+		 * @throws \InvalidArgumentException
+		 * @throws \DomainException
+		 */
+		get { // error - DomainException unused
+			throw new \InvalidArgumentException();
+		}
+	}
+
+
+	public int $j {
+		/** @throws \DomainException */
+		get { // error - DomainException unused
+
+		}
+	}
+
+}