Validate types to throw

Author: pepakriz

conf/config.level3.neon

@@ -10,6 +10,7 @@ rules:
 - PHPStan\Rules\Methods\ReturnTypeRule
 - PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule
 - PHPStan\Rules\Properties\TypesAssignedToPropertiesRule
+- PHPStan\Rules\Variables\ThrowTypeRule
 - PHPStan\Rules\Variables\VariableCloningRule
 
 services:

src/Rules/Variables/ThrowTypeRule.php

@@ -0,0 +1,63 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Variables;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleLevelHelper;
+use PHPStan\Type\ErrorType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\VerbosityLevel;
+
+class ThrowTypeRule implements \PHPStan\Rules\Rule
+{
+
+/** @var \PHPStan\Rules\RuleLevelHelper */
+private $ruleLevelHelper;
+
+public function __construct(
+RuleLevelHelper $ruleLevelHelper
+)
+{
+$this->ruleLevelHelper = $ruleLevelHelper;
+}
+
+public function getNodeType(): string
+{
+return \PhpParser\Node\Stmt\Throw_::class;
+}
+
+/**
+ * @param \PhpParser\Node\Stmt\Throw_ $node
+ * @param \PHPStan\Analyser\Scope $scope
+ * @return string[]
+ */
+public function processNode(Node $node, Scope $scope): array
+{
+$throwableType = new ObjectType(\Throwable::class);
+$typeResult = $this->ruleLevelHelper->findTypeToCheck(
+$scope,
+$node->expr,
+'Throwing object of an unknown class %s.',
+function (Type $type) use ($throwableType): bool {
+return $throwableType->isSuperTypeOf($type)->yes();
+}
+);
+
+$foundType = $typeResult->getType();
+if ($foundType instanceof ErrorType) {
+return $typeResult->getUnknownClassErrors();
+}
+
+$isSuperType = $throwableType->isSuperTypeOf($foundType);
+if ($isSuperType->yes()) {
+return [];
+}
+
+return [
+sprintf('Invalid type %s to throw.', $foundType->describe(VerbosityLevel::typeOnly())),
+];
+}
+
+}

tests/PHPStan/Levels/LevelsIntegrationTest.php

@@ -19,6 +19,7 @@ public function dataTopics(): array
 ['clone'],
 ['iterable'],
 ['binaryOps'],
+['throwValues'],
 ];
 }
 

tests/PHPStan/Levels/data/throwValues-3.json

@@ -0,0 +1,22 @@
+[
+ {
+ "message": "Invalid type int to throw.",
+ "line": 39,
+ "ignorable": true
+ },
+ {
+ "message": "Invalid type Levels\\ThrowValues\\InvalidException to throw.",
+ "line": 40,
+ "ignorable": true
+ },
+ {
+ "message": "Invalid type Levels\\ThrowValues\\InvalidInterfaceException to throw.",
+ "line": 41,
+ "ignorable": true
+ },
+ {
+ "message": "Invalid type int|string to throw.",
+ "line": 44,
+ "ignorable": true
+ }
+]

tests/PHPStan/Levels/data/throwValues-6.json

@@ -0,0 +1,7 @@
+[
+ {
+ "message": "Invalid type int|Throwable to throw.",
+ "line": 43,
+ "ignorable": true
+ }
+]

tests/PHPStan/Levels/data/throwValues-7.json

@@ -0,0 +1,7 @@
+[
+ {
+ "message": "Invalid type Exception|null to throw.",
+ "line": 42,
+ "ignorable": true
+ }
+]

tests/PHPStan/Levels/data/throwValues.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Levels\ThrowValues;
+
+class InvalidException
+{
+
+}
+
+interface InvalidInterfaceException
+{
+
+}
+
+interface ValidInterfaceException extends \Throwable
+{
+
+}
+
+class Foo
+{
+
+/**
+ * @param ValidInterfaceException $validInterface
+ * @param InvalidInterfaceException $invalidInterface
+ * @param \Exception|null $nullableException
+ * @param \Throwable|int $throwableOrInt
+ * @param int|string $intOrString
+ */
+public function doFoo(
+ValidInterfaceException $validInterface,
+InvalidInterfaceException $invalidInterface,
+?\Exception $nullableException,
+$throwableOrInt,
+$intOrString
+) {
+throw new \Exception();
+throw $validInterface;
+throw 123;
+throw new InvalidException();
+throw $invalidInterface;
+throw $nullableException;
+throw $throwableOrInt;
+throw $intOrString;
+}
+
+}

tests/PHPStan/Rules/Variables/ThrowTypeRuleTest.php

@@ -0,0 +1,44 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Variables;
+
+use PHPStan\Rules\RuleLevelHelper;
+
+class ThrowTypeRuleTest extends \PHPStan\Testing\RuleTestCase
+{
+
+protected function getRule(): \PHPStan\Rules\Rule
+{
+return new ThrowTypeRule(new RuleLevelHelper($this->createBroker(), true, false, true));
+}
+
+public function testAccessPropertiesOnPossiblyNullRuleTest(): void
+{
+$this->analyse(
+[__DIR__ . '/data/throw-values.php'],
+[
+[
+'Invalid type int to throw.',
+19,
+],
+[
+'Invalid type ThrowValues\InvalidException to throw.',
+20,
+],
+[
+'Invalid type ThrowValues\InvalidInterfaceException to throw.',
+21,
+],
+[
+'Invalid type Exception|null to throw.',
+22,
+],
+[
+'Throwing object of an unknown class ThrowValues\NonexistentClass.',
+24,
+],
+]
+);
+}
+
+}

tests/PHPStan/Rules/Variables/data/throw-values.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace ThrowValues;
+
+class InvalidException {};
+interface InvalidInterfaceException {};
+interface ValidInterfaceException extends \Throwable {};
+
+function () {
+/** @var ValidInterfaceException $validInterface */
+$validInterface = new \Exception();
+/** @var InvalidInterfaceException $invalidInterface */
+$invalidInterface = new \Exception();
+/** @var \Exception|null $nullableException */
+$nullableException = new \Exception();
+
+throw new \Exception();
+throw $validInterface;
+throw 123;
+throw new InvalidException();
+throw $invalidInterface;
+throw $nullableException;
+throw foo();
+throw new NonexistentClass();
+};