Configuration for uncheckedExceptions

Author: pepakriz

README.md

@@ -48,7 +48,19 @@ parameters:
 			- RuntimeException
 ```
 
-If some third-party code defines wrong throw types, you could override definitions like this:
+You could use `uncheckedExceptions` when you prefer a list of unchecked exceptions instead. It is a safer variant, but harder to adapt to the existing project.
+
+```neon
+parameters:
+	exceptionRules:
+		uncheckedExceptions:
+			- LogicException
+			- PHPUnit\Framework\Exception
+```
+
+> `checkedExceptions` and `uncheckedExceptions` cannot be configured at the same time
+
+If some third-party code defines wrong throw types (or it doesn't use @throws annotations at all), you could override definitions like this:
 
 ```neon
 parameters:

extension.neon

@@ -2,6 +2,7 @@ parameters:
 	exceptionRules:
 		reportMaybes: true
 		checkedExceptions: []
+		uncheckedExceptions: []
 		methodThrowTypeDeclarations: []
 		functionThrowTypeDeclarations: []
 
@@ -10,7 +11,7 @@ extensions:
 
 services:
 	-
-		class: Pepakriz\PHPStanExceptionRules\CheckedExceptionService(%exceptionRules.checkedExceptions%)
+		class: Pepakriz\PHPStanExceptionRules\CheckedExceptionService(%exceptionRules.checkedExceptions%, %exceptionRules.uncheckedExceptions%)
 
 	-
 		class: Pepakriz\PHPStanExceptionRules\DefaultThrowTypeExtension(%exceptionRules.methodThrowTypeDeclarations%, %exceptionRules.functionThrowTypeDeclarations%)

phpstan.neon.dist

@@ -12,5 +12,17 @@ parameters:
 		- %rootDir%/../../../tests/*/data/*
 
 	exceptionRules:
-		checkedExceptions:
-			- Pepakriz\PHPStanExceptionRules\RuntimeException
+		uncheckedExceptions:
+			- LogicException
+			- PHPStan\ShouldNotHappenException
+			- PHPUnit\Framework\Exception
+			- Nette\DI\MissingServiceException
+		methodThrowTypeDeclarations:
+			PHPStan\Broker\Broker:
+				getClass:
+					- PHPStan\Broker\ClassNotFoundException
+				getFunction:
+					- PHPStan\Broker\FunctionNotFoundException
+			PHPStan\Reflection\ClassReflection:
+				getMethod:
+					- PHPStan\Reflection\MissingMethodFromReflectionException

src/CheckedExceptionService.php

@@ -2,25 +2,41 @@
 
 namespace Pepakriz\PHPStanExceptionRules;
 
+use LogicException;
 use function array_filter;
+use function count;
 use function is_a;
 
 class CheckedExceptionService
 {
 
 	/**
-	 * @var string[]
+	 * @var string[]|null
 	 */
 	private $checkedExceptions;
 
+	/**
+	 * @var string[]
+	 */
+	private $uncheckedExceptions;
+
 	/**
 	 * @param string[] $checkedExceptions
+	 * @param string[] $uncheckedExceptions
 	 */
 	public function __construct(
-		array $checkedExceptions
+		array $checkedExceptions,
+		array $uncheckedExceptions = []
 	)
 	{
-		$this->checkedExceptions = $checkedExceptions;
+		$checkedExceptionsCounter = count($checkedExceptions);
+		$uncheckedExceptionsCounter = count($uncheckedExceptions);
+		if ($checkedExceptionsCounter > 0 && $uncheckedExceptionsCounter > 0) {
+			throw new LogicException('$checkedExceptions and $uncheckedExceptions cannot be configured at the same time');
+		}
+
+		$this->checkedExceptions = $checkedExceptionsCounter > 0 ? $checkedExceptions : null;
+		$this->uncheckedExceptions = $uncheckedExceptions;
 	}
 
 	/**
@@ -36,13 +52,23 @@ public function filterCheckedExceptions(array $classes): array
 
 	public function isCheckedException(string $exceptionClassName): bool
 	{
-		foreach ($this->checkedExceptions as $whitelistedException) {
-			if (is_a($exceptionClassName, $whitelistedException, true)) {
-				return true;
+		if ($this->checkedExceptions !== null) {
+			foreach ($this->checkedExceptions as $checkedException) {
+				if (is_a($exceptionClassName, $checkedException, true)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		foreach ($this->uncheckedExceptions as $uncheckedException) {
+			if (is_a($exceptionClassName, $uncheckedException, true)) {
+				return false;
 			}
 		}
 
-		return false;
+		return true;
 	}
 
 }

src/Rules/ThrowsPhpDocInheritanceRule.php

@@ -7,8 +7,11 @@
 use PhpParser\Node\Stmt\ClassMethod;
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
+use PHPStan\Broker\ClassNotFoundException;
+use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\ThrowableReflection;
 use PHPStan\Rules\Rule;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
@@ -97,12 +100,18 @@ public function processNode(Node $node, Scope $scope): array
 
 		$messages = [];
 		foreach ($parentClasses as $parentClass) {
-			$parentClassReflection = $this->broker->getClass($parentClass->getName());
-			if (!$parentClassReflection->hasMethod($methodName)) {
+			try {
+				$parentClassReflection = $this->broker->getClass($parentClass->getName());
+			} catch (ClassNotFoundException $e) {
+				throw new ShouldNotHappenException();
+			}
+
+			try {
+				$methodReflection = $parentClassReflection->getMethod($methodName, $scope);
+			} catch (MissingMethodFromReflectionException $e) {
 				continue;
 			}
 
-			$methodReflection = $parentClassReflection->getMethod($methodName, $scope);
 			if (!$methodReflection instanceof ThrowableReflection) {
 				continue;
 			}

src/Rules/ThrowsPhpDocRule.php

@@ -30,6 +30,7 @@
 use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\ThrowableReflection;
 use PHPStan\Rules\Rule;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
@@ -193,12 +194,18 @@ private function processMethodCall(MethodCall $node, Scope $scope): array
 
 		$throwTypes = [];
 		foreach ($targetClassNames as $targetClassName) {
-			$targetClassReflection = $this->broker->getClass($targetClassName);
-			if (!$targetClassReflection->hasMethod($methodName->toString())) {
+			try {
+				$targetClassReflection = $this->broker->getClass($targetClassName);
+			} catch (ClassNotFoundException $e) {
+				throw new ShouldNotHappenException();
+			}
+
+			try {
+				$targetMethodReflection = $targetClassReflection->getMethod($methodName->toString(), $scope);
+			} catch (MissingMethodFromReflectionException $e) {
 				continue;
 			}
 
-			$targetMethodReflection = $targetClassReflection->getMethod($methodName->toString(), $scope);
 			if (!$targetMethodReflection instanceof ThrowableReflection) {
 				continue;
 			}
@@ -302,7 +309,12 @@ private function processClassMethod(ClassMethod $node, Scope $scope): array
 			return [];
 		}
 
-		$methodReflection = $classReflection->getMethod($node->name->toString(), $scope);
+		try {
+			$methodReflection = $classReflection->getMethod($node->name->toString(), $scope);
+		} catch (MissingMethodFromReflectionException $e) {
+			throw new ShouldNotHappenException();
+		}
+
 		if ($methodReflection instanceof ThrowableReflection) {
 			$this->throwsScope->enterToThrowsAnnotationBlock($methodReflection->getThrowType());
 		}