Bleeding edge - report implicit (inherited) too-wide @throws type

Author: ondrejmirtes

conf/bleedingEdge.neon

@@ -15,3 +15,4 @@ parameters:
 		reportNestedTooWideType: false
 		assignToByRefForeachExpr: true
 		curlSetOptArrayTypes: true
+		tooWideImplicitThrows: true

conf/config.level4.neon

@@ -24,6 +24,7 @@ services:
 		class: PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule
 		arguments:
 			checkProtectedAndPublicMethods: %checkTooWideThrowTypesInProtectedAndPublicMethods%
+			tooWideImplicitThrows: %featureToggles.tooWideImplicitThrows%
 
 	-
 		class: PHPStan\Rules\Exceptions\TooWidePropertyHookThrowTypeRule

conf/config.neon

@@ -40,6 +40,7 @@ parameters:
 		reportNestedTooWideType: false
 		assignToByRefForeachExpr: false
 		curlSetOptArrayTypes: false
+		tooWideImplicitThrows: false
 	fileExtensions:
 		- php
 	checkAdvancedIsset: false

conf/parametersSchema.neon

@@ -43,6 +43,7 @@ parametersSchema:
 		reportNestedTooWideType: bool()
 		assignToByRefForeachExpr: bool()
 		curlSetOptArrayTypes: bool()
+		tooWideImplicitThrows: bool()
 	])
 	fileExtensions: listOf(string())
 	checkAdvancedIsset: bool()

src/Rules/Exceptions/TooWideMethodThrowTypeRule.php

@@ -7,6 +7,7 @@
 use PHPStan\Node\MethodReturnStatementsNode;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\FileTypeMapper;
 use function sprintf;
 
 /**
@@ -16,8 +17,10 @@ final class TooWideMethodThrowTypeRule implements Rule
 {
 
 	public function __construct(
+		private FileTypeMapper $fileTypeMapper,
 		private TooWideThrowTypeCheck $check,
 		private bool $checkProtectedAndPublicMethods,
+		private bool $tooWideImplicitThrows,
 	)
 	{
 	}
@@ -49,8 +52,34 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
+		$unusedThrowClasses = $this->check->check($throwType, $statementResult->getThrowPoints());
+		if (!$this->tooWideImplicitThrows) {
+			$docComment = $node->getDocComment();
+			if ($docComment === null) {
+				return [];
+			}
+
+			$classReflection = $node->getClassReflection();
+			$resolvedPhpDoc = $this->fileTypeMapper->getResolvedPhpDoc(
+				$scope->getFile(),
+				$classReflection->getName(),
+				$scope->isInTrait() ? $scope->getTraitReflection()->getName() : null,
+				$method->getName(),
+				$docComment->getText(),
+			);
+
+			if ($resolvedPhpDoc->getThrowsTag() === null) {
+				return [];
+			}
+
+			$explicitThrowType = $resolvedPhpDoc->getThrowsTag()->getType();
+			if ($explicitThrowType->equals($throwType)) {
+				return [];
+			}
+		}
+
 		$errors = [];
-		foreach ($this->check->check($throwType, $statementResult->getThrowPoints()) as $throwClass) {
+		foreach ($unusedThrowClasses as $throwClass) {
 			$errors[] = RuleErrorBuilder::message(sprintf(
 				'Method %s::%s() has %s in PHPDoc @throws tag but it\'s not thrown.',
 				$method->getDeclaringClass()->getDisplayName(),

tests/PHPStan/Rules/Exceptions/TooWideMethodThrowTypeRuleTest.php

@@ -4,6 +4,7 @@
 
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\RequiresPhp;
 
@@ -17,9 +18,16 @@ class TooWideMethodThrowTypeRuleTest extends RuleTestCase
 
 	private bool $checkProtectedAndPublicMethods = true;
 
+	private bool $tooWideImplicitThrows = true;
+
 	protected function getRule(): Rule
 	{
-		return new TooWideMethodThrowTypeRule(new TooWideThrowTypeCheck($this->implicitThrows), $this->checkProtectedAndPublicMethods);
+		return new TooWideMethodThrowTypeRule(
+			self::getContainer()->getByType(FileTypeMapper::class),
+			new TooWideThrowTypeCheck($this->implicitThrows),
+			$this->checkProtectedAndPublicMethods,
+			$this->tooWideImplicitThrows,
+		);
 	}
 
 	public function testRule(): void
@@ -150,4 +158,32 @@ public function testAlwaysCheckFinal(bool $checkProtectedAndPublicMethods, array
 		$this->analyse([__DIR__ . '/data/too-wide-throw-type-always-check-final.php'], $expectedErrors);
 	}
 
+	public static function dataTooWideImplicitThrows(): iterable
+	{
+		yield [
+			false,
+			[],
+		];
+
+		yield [
+			true,
+			[
+				[
+					'Method TooWideImplicitThrows\Bar::doFoo() has LogicException in PHPDoc @throws tag but it\'s not thrown.',
+					23,
+				],
+			],
+		];
+	}
+
+	/**
+	 * @param list<array{0: string, 1: int, 2?: string|null}> $expectedErrors
+	 */
+	#[DataProvider('dataTooWideImplicitThrows')]
+	public function testTooWideImplicitThrows(bool $tooWideImplicitThrows, array $expectedErrors): void
+	{
+		$this->tooWideImplicitThrows = $tooWideImplicitThrows;
+		$this->analyse([__DIR__ . '/data/too-wide-implicit-throws.php'], $expectedErrors);
+	}
+
 }

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

@@ -0,0 +1,28 @@
+<?php
+
+namespace TooWideImplicitThrows;
+
+use LogicException;
+
+class Foo
+{
+
+	/**
+	 * @throws LogicException
+	 */
+	public function doFoo(): void
+	{
+		throw new LogicException();
+	}
+
+}
+
+final class Bar extends Foo
+{
+
+	public function doFoo(): void
+	{
+
+	}
+
+}