DynamicThrowExtension: better solution for dynamic contructor extensions

pepakriz · pepakriz · commit 531c9fe76b2e · 2018-08-12T20:50:37.000+02:00
diff --git a/README.md b/README.md
@@ -84,6 +84,7 @@ There are interfaces, which you can implement:
 
 * `Pepakriz\PHPStanExceptionRules\DynamicMethodThrowTypeExtension` - service tag: `exceptionRules.dynamicMethodThrowTypeExtension`
 * `Pepakriz\PHPStanExceptionRules\DynamicStaticMethodThrowTypeExtension` - service tag: `exceptionRules.dynamicStaticMethodThrowTypeExtension`
+* `Pepakriz\PHPStanExceptionRules\DynamicConstructorThrowTypeExtension` - service tag: `exceptionRules.dynamicConstructorThrowTypeExtension`
 * `Pepakriz\PHPStanExceptionRules\DynamicFunctionThrowTypeExtension` - service tag: `exceptionRules.dynamicFunctionThrowTypeExtension`
 
 and register as service with correct tag:
diff --git a/extension.neon b/extension.neon
@@ -18,6 +18,7 @@ services:
 		tags:
 			- exceptionRules.dynamicMethodThrowTypeExtension
 			- exceptionRules.dynamicStaticMethodThrowTypeExtension
+			- exceptionRules.dynamicConstructorThrowTypeExtension
 			- exceptionRules.dynamicFunctionThrowTypeExtension
 
 	-
diff --git a/src/DI/ExceptionRulesExtension.php b/src/DI/ExceptionRulesExtension.php
@@ -13,6 +13,7 @@ class ExceptionRulesExtension extends CompilerExtension
 
 	private const TAG_DYNAMIC_METHOD_THROW_TYPE = 'exceptionRules.dynamicMethodThrowTypeExtension';
 	private const TAG_DYNAMIC_STATIC_METHOD_THROW_TYPE = 'exceptionRules.dynamicStaticMethodThrowTypeExtension';
+	private const TAG_DYNAMIC_CONSTRUCTOR_THROW_TYPE = 'exceptionRules.dynamicConstructorThrowTypeExtension';
 	private const TAG_DYNAMIC_FUNCTION_THROW_TYPE = 'exceptionRules.dynamicFunctionThrowTypeExtension';
 
 	public function beforeCompile(): void
@@ -23,6 +24,7 @@ public function beforeCompile(): void
 			->setArguments([
 				$this->getServicesByNames(self::TAG_DYNAMIC_METHOD_THROW_TYPE),
 				$this->getServicesByNames(self::TAG_DYNAMIC_STATIC_METHOD_THROW_TYPE),
+				$this->getServicesByNames(self::TAG_DYNAMIC_CONSTRUCTOR_THROW_TYPE),
 				$this->getServicesByNames(self::TAG_DYNAMIC_FUNCTION_THROW_TYPE),
 			]);
 	}
diff --git a/src/DefaultThrowTypeExtension.php b/src/DefaultThrowTypeExtension.php
@@ -4,6 +4,7 @@
 
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\New_;
 use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
@@ -15,7 +16,7 @@
 use function array_map;
 use function count;
 
-class DefaultThrowTypeExtension implements DynamicFunctionThrowTypeExtension, DynamicMethodThrowTypeExtension, DynamicStaticMethodThrowTypeExtension
+class DefaultThrowTypeExtension implements DynamicFunctionThrowTypeExtension, DynamicMethodThrowTypeExtension, DynamicConstructorThrowTypeExtension, DynamicStaticMethodThrowTypeExtension
 {
 
 	/**
@@ -97,6 +98,18 @@ public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflect
 		return $this->getMethodThrowType($methodReflection);
 	}
 
+	/**
+	 * @throws UnsupportedClassException
+	 */
+	public function getThrowTypeFromConstructor(MethodReflection $methodReflection, New_ $newNode, Scope $scope): Type
+	{
+		try {
+			return $this->getMethodThrowType($methodReflection);
+		} catch (UnsupportedFunctionException $e) {
+			throw new UnsupportedClassException();
+		}
+	}
+
 	/**
 	 * @throws UnsupportedClassException
 	 * @throws UnsupportedFunctionException
diff --git a/src/DynamicConstructorThrowTypeExtension.php b/src/DynamicConstructorThrowTypeExtension.php
@@ -0,0 +1,18 @@
+<?php declare(strict_types = 1);
+
+namespace Pepakriz\PHPStanExceptionRules;
+
+use PhpParser\Node\Expr\New_;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\Type;
+
+interface DynamicConstructorThrowTypeExtension
+{
+
+	/**
+	 * @throws UnsupportedClassException
+	 */
+	public function getThrowTypeFromConstructor(MethodReflection $methodReflection, New_ $newNode, Scope $scope): Type;
+
+}
diff --git a/src/DynamicThrowTypeService.php b/src/DynamicThrowTypeService.php
@@ -4,6 +4,7 @@
 
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\New_;
 use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
@@ -27,6 +28,11 @@ class DynamicThrowTypeService
 	 */
 	private $dynamicStaticMethodThrowTypeExtensions = [];
 
+	/**
+	 * @var DynamicConstructorThrowTypeExtension[]
+	 */
+	private $dynamicConstructorThrowTypeExtensions = [];
+
 	/**
 	 * @var DynamicFunctionThrowTypeExtension[]
 	 */
@@ -45,11 +51,13 @@ class DynamicThrowTypeService
 	/**
 	 * @param DynamicMethodThrowTypeExtension[] $dynamicMethodThrowTypeExtensions
 	 * @param DynamicStaticMethodThrowTypeExtension[] $dynamicStaticMethodThrowTypeExtensions
+	 * @param DynamicConstructorThrowTypeExtension[] $dynamicConstructorThrowTypeExtensions
 	 * @param DynamicFunctionThrowTypeExtension[] $dynamicFunctionThrowTypeExtensions
 	 */
 	public function __construct(
 		array $dynamicMethodThrowTypeExtensions,
 		array $dynamicStaticMethodThrowTypeExtensions,
+		array $dynamicConstructorThrowTypeExtensions,
 		array $dynamicFunctionThrowTypeExtensions
 	)
 	{
@@ -61,6 +69,10 @@ public function __construct(
 			$this->addDynamicStaticMethodExtension($dynamicStaticMethodThrowTypeExtension);
 		}
 
+		foreach ($dynamicConstructorThrowTypeExtensions as $dynamicConstructorThrowTypeExtension) {
+			$this->addDynamicConstructorExtension($dynamicConstructorThrowTypeExtension);
+		}
+
 		foreach ($dynamicFunctionThrowTypeExtensions as $dynamicFunctionThrowTypeExtension) {
 			$this->addDynamicFunctionExtension($dynamicFunctionThrowTypeExtension);
 		}
@@ -76,6 +88,11 @@ private function addDynamicStaticMethodExtension(DynamicStaticMethodThrowTypeExt
 		$this->dynamicStaticMethodThrowTypeExtensions[] = $extension;
 	}
 
+	private function addDynamicConstructorExtension(DynamicConstructorThrowTypeExtension $extension): void
+	{
+		$this->dynamicConstructorThrowTypeExtensions[] = $extension;
+	}
+
 	private function addDynamicFunctionExtension(DynamicFunctionThrowTypeExtension $extension): void
 	{
 		$this->dynamicFunctionThrowTypeExtensions[] = $extension;
@@ -145,6 +162,36 @@ public function getStaticMethodThrowType(MethodReflection $methodReflection, Sta
 		return $throwType !== null ? $throwType : new VoidType();
 	}
 
+	public function getConstructorThrowType(MethodReflection $methodReflection, New_ $newNode, Scope $scope): Type
+	{
+		$classReflection = $methodReflection->getDeclaringClass();
+
+		$functionName = sprintf('%s::%s', $classReflection->getName(), $methodReflection->getName());
+		foreach ($this->dynamicConstructorThrowTypeExtensions as $extension) {
+			$extensionHash = spl_object_hash($extension);
+			if (isset($this->unsupportedClasses[$classReflection->getName()][$extensionHash])) {
+				continue;
+			}
+
+			if (isset($this->unsupportedFunctions[$functionName][$extensionHash])) {
+				continue;
+			}
+
+			try {
+				return $extension->getThrowTypeFromConstructor($methodReflection, $newNode, $scope);
+			} catch (UnsupportedClassException $e) {
+				$this->unsupportedClasses[$classReflection->getName()][$extensionHash] = true;
+			}
+		}
+
+		$throwType = null;
+		if ($methodReflection instanceof ThrowableReflection) {
+			$throwType = $methodReflection->getThrowType();
+		}
+
+		return $throwType !== null ? $throwType : new VoidType();
+	}
+
 	public function getFunctionThrowType(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): Type
 	{
 		$functionName = $functionReflection->getName();
diff --git a/src/Rules/ThrowsPhpDocRule.php b/src/Rules/ThrowsPhpDocRule.php
@@ -269,26 +269,22 @@ private function processStaticCall(StaticCall $node, Scope $scope): array
 	 */
 	private function processNew(New_ $node, Scope $scope): array
 	{
-		$class = $node->class;
-		if ($class instanceof Node\Stmt\Class_) {
-			$className = $class->name;
-			if ($className === null) {
-				$class = $class->extends;
-				if ($class === null) {
-					return []; // trait without extends
-				}
-			} else {
-				$class = new Name($className->toString());
+		$throwTypes = [];
+		$targetMethodReflections = $this->getMethodReflections($node->class, ['__construct'], $scope);
+		foreach ($targetMethodReflections as $targetMethodReflection) {
+			$throwType = $this->dynamicThrowTypeService->getConstructorThrowType($targetMethodReflection, $node, $scope);
+			if ($throwType instanceof VoidType) {
+				continue;
 			}
+
+			$throwTypes[] = $throwType;
 		}
 
-		$methodCall = new StaticCall(
-			$class,
-			new Identifier('__construct'),
-			$node->args
-		);
+		if (count($throwTypes) === 0) {
+			return [];
+		}
 
-		return $this->processStaticCall($methodCall, $scope);
+		return $this->processThrowsTypes(TypeCombinator::union(...$throwTypes));
 	}
 
 	/**
diff --git a/tests/src/Rules/ThrowsPhpDocRuleTest.php b/tests/src/Rules/ThrowsPhpDocRuleTest.php
@@ -34,6 +34,8 @@ protected function getRule(): Rule
 				$dynamicExtension,
 			], [
 				$dynamicExtension,
+			], [
+				$dynamicExtension,
 			]),
 			$this->createBroker(),
 			$this->reportUnusedCatchesOfUncheckedExceptions
diff --git a/tests/src/Rules/data/dynamic-extension.php b/tests/src/Rules/data/dynamic-extension.php
@@ -2,13 +2,15 @@
 
 namespace Pepakriz\PHPStanExceptionRules\Rules\DynamicExtension;
 
+use Pepakriz\PHPStanExceptionRules\DynamicConstructorThrowTypeExtension;
 use Pepakriz\PHPStanExceptionRules\DynamicFunctionThrowTypeExtension;
 use Pepakriz\PHPStanExceptionRules\DynamicMethodThrowTypeExtension;
 use Pepakriz\PHPStanExceptionRules\DynamicStaticMethodThrowTypeExtension;
 use Pepakriz\PHPStanExceptionRules\UnsupportedClassException;
 use Pepakriz\PHPStanExceptionRules\UnsupportedFunctionException;
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\New_;
 use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
@@ -17,7 +19,7 @@
 use PHPStan\Type\Type;
 use RuntimeException;
 
-class DynamicExtension implements DynamicMethodThrowTypeExtension, DynamicStaticMethodThrowTypeExtension, DynamicFunctionThrowTypeExtension
+class DynamicExtension implements DynamicMethodThrowTypeExtension, DynamicStaticMethodThrowTypeExtension, DynamicConstructorThrowTypeExtension, DynamicFunctionThrowTypeExtension
 {
 
 	/**
@@ -48,10 +50,6 @@ public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflect
 				return new ObjectType(RuntimeException::class);
 			}
 
-			if ($methodReflection->getName() === '__construct') {
-				return new ObjectType(RuntimeException::class);
-			}
-
 			throw new UnsupportedFunctionException();
 		}
 
@@ -66,6 +64,18 @@ public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflect
 		throw new UnsupportedClassException();
 	}
 
+	/**
+	 * @throws UnsupportedClassException
+	 */
+	public function getThrowTypeFromConstructor(MethodReflection $methodReflection, New_ $newNode, Scope $scope): Type
+	{
+		if ($methodReflection->getDeclaringClass()->getName() === TestClass::class) {
+			return new ObjectType(RuntimeException::class);
+		}
+
+		throw new UnsupportedClassException();
+	}
+
 	/**
 	 * @throws UnsupportedFunctionException
 	 */

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ services:`
`18`	`18`	`tags:`
`19`	`19`	`- exceptionRules.dynamicMethodThrowTypeExtension`
`20`	`20`	`- exceptionRules.dynamicStaticMethodThrowTypeExtension`
	`21`	`+ - exceptionRules.dynamicConstructorThrowTypeExtension`
`21`	`22`	`- exceptionRules.dynamicFunctionThrowTypeExtension`
`22`	`23`
`23`	`24`	`-`