Implementation of DefaultThrowTypeExtension which could override @thr…

README.md

@@ -48,6 +48,21 @@ parameters:
 			- RuntimeException
 ```
 
+If some third-party code defines wrong throw types, you could override definitions like this:
+
+```neon
+parameters:
+	exceptionRules:
+		methodThrowTypeDeclarations:
+			FooProject\SomeService:
+				sendMessage:
+					- FooProject\ConnectionTimeoutException
+				methodWithoutException: []
+		functionThrowTypeDeclarations:
+			myFooFunction:
+				- FooException
+```
+
 ## Extensibility
 
 `Dynamic throw type extensions` - If the throw type is not always the same, but depends on an argument passed to the method. (Similar feature as [Dynamic return type extensions](https://github.com/phpstan/phpstan#dynamic-return-type-extensions))

extension.neon

@@ -2,6 +2,8 @@ parameters:
 	exceptionRules:
 		reportMaybes: true
 		checkedExceptions: []
+		methodThrowTypeDeclarations: []
+		functionThrowTypeDeclarations: []
 
 extensions:
 	exceptionRules: Pepakriz\PHPStanExceptionRules\DI\ExceptionRulesExtension
@@ -10,6 +12,13 @@ services:
 	-
 		class: Pepakriz\PHPStanExceptionRules\CheckedExceptionService(%exceptionRules.checkedExceptions%)
 
+	-
+		class: Pepakriz\PHPStanExceptionRules\DefaultThrowTypeExtension(%exceptionRules.methodThrowTypeDeclarations%, %exceptionRules.functionThrowTypeDeclarations%)
+		tags:
+			- exceptionRules.dynamicMethodThrowTypeExtension
+			- exceptionRules.dynamicStaticMethodThrowTypeExtension
+			- exceptionRules.dynamicFunctionThrowTypeExtension
+
 	-
 		class: Pepakriz\PHPStanExceptionRules\Rules\ThrowsPhpDocRule
 		tags: [phpstan.rules.rule]

phpstan.neon.dist

@@ -12,4 +12,5 @@ parameters:
 		- %rootDir%/../../../tests/*/data/*
 
 	exceptionRules:
-		checkedExceptions: []
+		checkedExceptions:
+			- Pepakriz\PHPStanExceptionRules\RuntimeException

src/DefaultThrowTypeExtension.php

@@ -0,0 +1,123 @@
+<?php declare(strict_types = 1);
+
+namespace Pepakriz\PHPStanExceptionRules;
+
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use function array_map;
+
+class DefaultThrowTypeExtension implements DynamicFunctionThrowTypeExtension, DynamicMethodThrowTypeExtension, DynamicStaticMethodThrowTypeExtension
+{
+
+	/**
+	 * @var string[][][]
+	 */
+	private $methodThrowTypes = [];
+
+	/**
+	 * @var string[][]
+	 */
+	private $functionThrowTypes = [];
+
+	/**
+	 * @param string[][][] $methodThrowTypes
+	 * @param string[][] $functionThrowTypes
+	 */
+	public function __construct(
+		array $methodThrowTypes,
+		array $functionThrowTypes
+	)
+	{
+		foreach ($methodThrowTypes as $className => $methods) {
+			foreach ($methods as $methodName => $throwTypes) {
+				$this->methodThrowTypes[$className][$methodName] = [];
+				foreach ($throwTypes as $throwType) {
+					$this->addMethodThrowType($className, $methodName, $throwType);
+				}
+			}
+		}
+
+		foreach ($functionThrowTypes as $functionName => $throwTypes) {
+			$this->functionThrowTypes[$functionName] = [];
+			foreach ($throwTypes as $throwType) {
+				$this->addFunctionThrowType($functionName, $throwType);
+			}
+		}
+	}
+
+	private function addMethodThrowType(string $className, string $methodName, string $throwType): void
+	{
+		$this->methodThrowTypes[$className][$methodName][] = $throwType;
+	}
+
+	private function addFunctionThrowType(string $functionName, string $throwType): void
+	{
+		$this->functionThrowTypes[$functionName][] = $throwType;
+	}
+
+	/**
+	 * @throws UnsupportedFunctionException
+	 */
+	public function getThrowTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): Type
+	{
+		$functionName = $functionReflection->getName();
+		if (!isset($this->functionThrowTypes[$functionName])) {
+			throw new UnsupportedFunctionException();
+		}
+
+		$throwTypes = array_map(function (string $className): ObjectType {
+			return new ObjectType($className);
+		}, $this->functionThrowTypes[$functionName]);
+
+		return TypeCombinator::union(...$throwTypes);
+	}
+
+	/**
+	 * @throws UnsupportedClassException
+	 * @throws UnsupportedFunctionException
+	 */
+	public function getThrowTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): Type
+	{
+		return $this->getMethodThrowType($methodReflection);
+	}
+
+	/**
+	 * @throws UnsupportedClassException
+	 * @throws UnsupportedFunctionException
+	 */
+	public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): Type
+	{
+		return $this->getMethodThrowType($methodReflection);
+	}
+
+	/**
+	 * @throws UnsupportedClassException
+	 * @throws UnsupportedFunctionException
+	 */
+	private function getMethodThrowType(MethodReflection $methodReflection): Type
+	{
+		$className = $methodReflection->getDeclaringClass()->getName();
+		if (!isset($this->methodThrowTypes[$className])) {
+			throw new UnsupportedClassException();
+		}
+
+		if (!isset($this->methodThrowTypes[$className][$methodReflection->getName()])) {
+			throw new UnsupportedFunctionException();
+		}
+
+		$throwTypeClasses = $this->methodThrowTypes[$className][$methodReflection->getName()];
+		$throwTypes = array_map(function (string $className): ObjectType {
+			return new ObjectType($className);
+		}, $throwTypeClasses);
+
+		return TypeCombinator::union(...$throwTypes);
+	}
+
+}

src/RuntimeException.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types = 1);
+
+namespace Pepakriz\PHPStanExceptionRules;
+
+use RuntimeException as CoreRuntimeException;
+
+abstract class RuntimeException extends CoreRuntimeException
+{
+
+}

src/UnsupportedClassException.php

@@ -2,8 +2,6 @@
 
 namespace Pepakriz\PHPStanExceptionRules;
 
-use RuntimeException;
-
 class UnsupportedClassException extends RuntimeException
 {
 

src/UnsupportedFunctionException.php

@@ -2,8 +2,6 @@
 
 namespace Pepakriz\PHPStanExceptionRules;
 
-use RuntimeException;
-
 class UnsupportedFunctionException extends RuntimeException
 {