Adding a rule to forbid catching of certain types of exceptions (#5)

Author: floriankraemer

data/CatchExceptionOfTypeNotAllowed/CatchAllowedException.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+class TestService
+{
+    public function methodWithAllowedCatch(): void
+    {
+        try {
+            // Some code that might throw an exception
+        } catch (\InvalidArgumentException $e) {
+            // This should NOT trigger an error (not in forbidden list)
+        }
+
+        try {
+            // Some code that might throw an exception
+        } catch (\RuntimeException $e) {
+            // This should NOT trigger an error (not in forbidden list)
+        }
+
+        try {
+            // Some code that might throw an exception
+        } catch (\DomainException $e) {
+            // This should NOT trigger an error (not in forbidden list)
+        }
+    }
+} 

data/CatchExceptionOfTypeNotAllowed/CatchForbiddenException.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+class TestService
+{
+    public function methodWithForbiddenCatch(): void
+    {
+        try {
+            // Some code that might throw an exception
+        } catch (\Exception $e) {
+            // This should trigger an error
+        }
+
+        try {
+            // Some code that might throw an error
+        } catch (\Error $e) {
+            // This should trigger an error
+        }
+
+        try {
+            // Some code that might throw a throwable
+        } catch (\Throwable $e) {
+            // This should trigger an error
+        }
+
+        try {
+            // Some code that might throw a specific exception
+        } catch (\InvalidArgumentException $e) {
+            // This should NOT trigger an error (not in forbidden list)
+        }
+    }
+} 

docs/Rules.md

@@ -99,6 +99,20 @@ Ensures that classes inside namespaces matching a given regex must have names ma
             - phpstan.rules.rule
 ```
 
+## Catch Exception of Type Not Allowed Rule
+
+Ensures that specific exception types are not caught in catch blocks. This is useful for preventing the catching of overly broad exception types like `Exception`, `Error`, or `Throwable`.
+
+**Configuration Example:**
+```neon
+    -
+        class: Phauthentic\PhpstanRules\Architecture\CatchExceptionOfTypeNotAllowedRule
+        arguments:
+            forbiddenExceptionTypes: ['Exception', 'Error', 'Throwable']
+        tags:
+            - phpstan.rules.rule
+```
+
 ## Method Signature Must Match Rule
 
 Ensures that methods matching a class and method name pattern have a specific signature, including parameter types, names, and count.

phpstan.neon

@@ -7,39 +7,40 @@ parameters:
 
 services:
     -
-        class: Phauthentic\PhpstanRules\CleanCode\ControlStructureNestingRule
+        class: Phauthentic\PHPStanRules\CleanCode\ControlStructureNestingRule
         arguments:
             maxNestingLevel: 2
         tags:
             - phpstan.rules.rule
     -
-        class: Phauthentic\PhpstanRules\CleanCode\TooManyArgumentsRule
+        class: Phauthentic\PHPStanRules\CleanCode\TooManyArgumentsRule
         arguments:
             maxArguments: 3
         tags:
             - phpstan.rules.rule
     -
-        class: Phauthentic\PhpstanRules\Architecture\ReadonlyClassRule
+        class: Phauthentic\PHPStanRules\Architecture\ClassMustBeReadonlyRule
         arguments:
             patterns: ['/^App\\Controller\\/']
         tags:
             - phpstan.rules.rule
     -
-        class: Phauthentic\PhpstanRules\Architecture\DependencyConstraintsRule
+        class: Phauthentic\PHPStanRules\Architecture\DependencyConstraintsRule
         arguments:
             forbiddenDependencies: [
                 '/^App\\Domain(?:\\\w+)*$/': ['/^App\\Controller\\/']
             ]
         tags:
             - phpstan.rules.rule
     -
-        class: Phauthentic\PhpstanRules\Architecture\FinalClassRule
+        class: Phauthentic\PHPStanRules\Architecture\ClassMustBeFinalRule
         arguments:
             patterns: ['/^App\\Service\\/']
         tags:
             - phpstan.rules.rule
     -
-        class: Phauthentic\PhpstanRules\Architecture\NamespaceClassPatternRule
+        class: Phauthentic\PHPStanRules\Architecture\ClassnameMustMatchPatternRule
+
         arguments:
             namespaceClassPatterns: [
                 [

src/Architecture/CatchExceptionOfTypeNotAllowedRule.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\PHPStanRules\Architecture;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Catch_;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<Catch_>
+ */
+class CatchExceptionOfTypeNotAllowedRule implements Rule
+{
+    private const ERROR_MESSAGE = 'Catching exception of type %s is not allowed.';
+
+    private const IDENTIFIER = 'phauthentic.architecture.catchExceptionOfTypeNotAllowed';
+
+    /**
+     * @var array<string> An array of exception class names that are not allowed to be caught.
+     * e.g., ['Exception', 'Error', 'Throwable']
+     */
+    private array $forbiddenExceptionTypes;
+
+    /**
+     * @param array<string> $forbiddenExceptionTypes An array of exception class names that are not allowed to be caught.
+     */
+    public function __construct(array $forbiddenExceptionTypes)
+    {
+        $this->forbiddenExceptionTypes = $forbiddenExceptionTypes;
+    }
+
+    public function getNodeType(): string
+    {
+        return Catch_::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (!$node instanceof Catch_) {
+            return [];
+        }
+
+        $errors = [];
+
+        foreach ($node->types as $type) {
+            $exceptionType = $type->toString();
+
+            // Check if the caught exception type is in the forbidden list
+            if (in_array($exceptionType, $this->forbiddenExceptionTypes, true)) {
+                $errors[] = RuleErrorBuilder::message(sprintf(self::ERROR_MESSAGE, $exceptionType))
+                    ->line($node->getLine())
+                    ->identifier(self::IDENTIFIER)
+                    ->build();
+            }
+        }
+
+        return $errors;
+    }
+}

tests/TestCases/Architecture/CatchExceptionOfTypeNotAllowedRuleTest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\PHPStanRules\Tests\TestCases\Architecture;
+
+use Phauthentic\PHPStanRules\Architecture\CatchExceptionOfTypeNotAllowedRule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<CatchExceptionOfTypeNotAllowedRule>
+ */
+class CatchExceptionOfTypeNotAllowedRuleTest extends RuleTestCase
+{
+    protected function getRule(): \PHPStan\Rules\Rule
+    {
+        return new CatchExceptionOfTypeNotAllowedRule([
+            'Exception',
+            'Error',
+            'Throwable',
+        ]);
+    }
+
+    public function testRule(): void
+    {
+        $this->analyse([__DIR__ . '/../../../data/CatchExceptionOfTypeNotAllowed/CatchForbiddenException.php'], [
+            [
+                'Catching exception of type Exception is not allowed.',
+                13,
+            ],
+            [
+                'Catching exception of type Error is not allowed.',
+                19,
+            ],
+            [
+                'Catching exception of type Throwable is not allowed.',
+                25,
+            ],
+        ]);
+    }
+
+    public function testAllowedExceptions(): void
+    {
+        $this->analyse([__DIR__ . '/../../../data/CatchExceptionOfTypeNotAllowed/CatchAllowedException.php'], []);
+    }
+}