SavinMikhail\CommentsDensity\MissingDocblock\UncaughtExceptionVisitor

Complexity

Total Complexity

39

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Test Coverage

Coverage

76.55%

Importance

Changes	9
Bugs	6	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	isInTryBlock()	0	10	4
A	getVariableType()	0	3	1
A	isSubclassOf()	0	12	5
B	enterNode()	0	16	7
B	isExceptionCaught()	0	24	7
A	getCurrentCatchStack()	0	7	2
A	isInCatchBlock()	0	8	3
A	nodeIsWithin()	0	4	2
A	leaveNode()	0	7	2
A	isRethrowingCaughtException()	0	15	6

<?php

declare(strict_types=1);

namespace SavinMikhail\CommentsDensity\MissingDocblock;

use PhpParser\Node;
use PhpParser\Node\Expr\Throw_;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Expr\New_;
use PhpParser\Node\Stmt\TryCatch;
use PhpParser\NodeVisitorAbstract;
use ReflectionClass;

final class UncaughtExceptionVisitor extends NodeVisitorAbstract
{
    public bool $hasUncaughtThrows = false;
    private array $tryCatchStack = [];

    public function enterNode(Node $node): null
    {
        if ($node instanceof TryCatch) {
            $this->tryCatchStack[] = $node;
        }

        if ($node instanceof Throw_) {
            if (!$this->isInTryBlock($node)) {
                $this->hasUncaughtThrows = true;
            } elseif (!$this->isExceptionCaught($node)) {
                $this->hasUncaughtThrows = true;
            } elseif ($this->isInCatchBlock($node) && !$this->isRethrowingCaughtException($node)) {
                $this->hasUncaughtThrows = true;
            }
        }
        return null;
    }

    public function leaveNode(Node $node): null
    {
        if ($node instanceof TryCatch) {
            array_pop($this->tryCatchStack);
        }

        return null;
    }

    private function isInCatchBlock(Throw_ $node): bool
    {
        foreach ($this->getCurrentCatchStack() as $catch) {
            if ($this->nodeIsWithin($node, $catch)) {
                return true;
            }
        }
        return false;
    }

    private function isInTryBlock(Throw_ $node): bool
    {
        foreach ($this->tryCatchStack as $tryCatch) {
            foreach ($tryCatch->stmts as $stmt) {
                if ($this->nodeIsWithin($node, $stmt)) {
                    return true;
                }
            }
        }
        return false;
    }

    private function isRethrowingCaughtException(Throw_ $throwNode): bool
    {
        $throwExpr = $throwNode->expr;

        if (!$throwExpr instanceof Variable || !isset($throwExpr->name)) {
            return false;
        }

        foreach ($this->getCurrentCatchStack() as $catch) {
            if ($catch->var instanceof Variable && $catch->var->name === $throwExpr->name) {
                return true;
            }
        }

        return false;
    }

    private function nodeIsWithin(Node $node, Node $container): bool
    {
        return $node->getStartFilePos() >= $container->getStartFilePos() &&
            $node->getEndFilePos() <= $container->getEndFilePos();
    }

    private function isExceptionCaught(Throw_ $throwNode): bool
    {
        $throwExpr = $throwNode->expr;

        if ($throwExpr instanceof Variable) {
            $thrownExceptionType = $this->getVariableType($throwExpr->name);

It seems like $throwExpr->name can also be of type PhpParser\Node\Expr; however, parameter $varName of SavinMikhail\CommentsDensity\MissingDocblock\UncaughtExceptionVisitor::getVariableType() does only seem to accept string, maybe add an additional type check?

        } elseif ($throwExpr instanceof New_) {
            $thrownExceptionType = (string)$throwExpr->class;
        } else {
            return false;
        }

        foreach ($this->getCurrentCatchStack() as $catch) {
            foreach ($catch->types as $catchType) {
                if (
                    $this->isSubclassOf($thrownExceptionType, (string)$catchType)
                    || (string)$catchType === 'Throwable'
                ) {
                    return true;
                }
            }
        }

        return false;
    }

    private function getCurrentCatchStack(): array
    {
        $catchStack = [];
        foreach ($this->tryCatchStack as $tryCatch) {
            $catchStack = array_merge($catchStack, $tryCatch->catches);
        }
        return $catchStack;
    }

    private function getVariableType(string $varName): ?string
    {
        return $varName;
    }

    private function isSubclassOf(?string $className, string $parentClassName): bool
    {
        if ($className === null) {
            return false;
        }

        if (!class_exists($className) || !class_exists($parentClassName)) {
            return false;
        }

        $reflectionClass = new ReflectionClass($className);
        return $reflectionClass->isSubclassOf($parentClassName) || $className === $parentClassName;
    }
}