<form method="POST">
    <h3>Editing: CodeUnitFindingVisitor.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of phpunit/php-code-coverage.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\CodeCoverage\StaticAnalysis;

use function assert;
use function implode;
use function rtrim;
use function trim;
use PhpParser\Node;
use PhpParser\Node\ComplexType;
use PhpParser\Node\Identifier;
use PhpParser\Node\IntersectionType;
use PhpParser\Node\Name;
use PhpParser\Node\NullableType;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Enum_;
use PhpParser\Node\Stmt\Function_;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Trait_;
use PhpParser\Node\UnionType;
use PhpParser\NodeAbstract;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use SebastianBergmann\Complexity\CyclomaticComplexityCalculatingVisitor;

/**
 * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
 */
final class CodeUnitFindingVisitor extends NodeVisitorAbstract
{
    /**
     * @psalm-var array&lt;string,array{name: string, namespacedName: string, namespace: string, startLine: int, endLine: int, methods: array&lt;string,array{methodName: string, signature: string, visibility: string, startLine: int, endLine: int, ccn: int}&gt;}&gt;
     */
    private $classes = [];

    /**
     * @psalm-var array&lt;string,array{name: string, namespacedName: string, namespace: string, startLine: int, endLine: int, methods: array&lt;string,array{methodName: string, signature: string, visibility: string, startLine: int, endLine: int, ccn: int}&gt;}&gt;
     */
    private $traits = [];

    /**
     * @psalm-var array&lt;string,array{name: string, namespacedName: string, namespace: string, signature: string, startLine: int, endLine: int, ccn: int}&gt;
     */
    private $functions = [];

    public function enterNode(Node $node): void
    {
        if ($node instanceof Class_) {
            if ($node-&gt;isAnonymous()) {
                return;
            }

            $this-&gt;processClass($node);
        }

        if ($node instanceof Trait_) {
            $this-&gt;processTrait($node);
        }

        if (!$node instanceof ClassMethod &amp;&amp; !$node instanceof Function_) {
            return;
        }

        if ($node instanceof ClassMethod) {
            $parentNode = $node-&gt;getAttribute('parent');

            if ($parentNode instanceof Class_ &amp;&amp; $parentNode-&gt;isAnonymous()) {
                return;
            }

            $this-&gt;processMethod($node);

            return;
        }

        $this-&gt;processFunction($node);
    }

    /**
     * @psalm-return array&lt;string,array{name: string, namespacedName: string, namespace: string, startLine: int, endLine: int, methods: array&lt;string,array{methodName: string, signature: string, visibility: string, startLine: int, endLine: int, ccn: int}&gt;}&gt;
     */
    public function classes(): array
    {
        return $this-&gt;classes;
    }

    /**
     * @psalm-return array&lt;string,array{name: string, namespacedName: string, namespace: string, startLine: int, endLine: int, methods: array&lt;string,array{methodName: string, signature: string, visibility: string, startLine: int, endLine: int, ccn: int}&gt;}&gt;
     */
    public function traits(): array
    {
        return $this-&gt;traits;
    }

    /**
     * @psalm-return array&lt;string,array{name: string, namespacedName: string, namespace: string, signature: string, startLine: int, endLine: int, ccn: int}&gt;
     */
    public function functions(): array
    {
        return $this-&gt;functions;
    }

    /**
     * @psalm-param ClassMethod|Function_ $node
     */
    private function cyclomaticComplexity(Node $node): int
    {
        assert($node instanceof ClassMethod || $node instanceof Function_);

        $nodes = $node-&gt;getStmts();

        if ($nodes === null) {
            return 0;
        }

        $traverser = new NodeTraverser;

        $cyclomaticComplexityCalculatingVisitor = new CyclomaticComplexityCalculatingVisitor;

        $traverser-&gt;addVisitor($cyclomaticComplexityCalculatingVisitor);

        /* @noinspection UnusedFunctionResultInspection */
        $traverser-&gt;traverse($nodes);

        return $cyclomaticComplexityCalculatingVisitor-&gt;cyclomaticComplexity();
    }

    /**
     * @psalm-param ClassMethod|Function_ $node
     */
    private function signature(Node $node): string
    {
        assert($node instanceof ClassMethod || $node instanceof Function_);

        $signature  = ($node-&gt;returnsByRef() ? '&amp;' : '') . $node-&gt;name-&gt;toString() . '(';
        $parameters = [];

        foreach ($node-&gt;getParams() as $parameter) {
            assert(isset($parameter-&gt;var-&gt;name));

            $parameterAsString = '';

            if ($parameter-&gt;type !== null) {
                $parameterAsString = $this-&gt;type($parameter-&gt;type) . ' ';
            }

            $parameterAsString .= '$' . $parameter-&gt;var-&gt;name;

            /* @todo Handle default values */

            $parameters[] = $parameterAsString;
        }

        $signature .= implode(', ', $parameters) . ')';

        $returnType = $node-&gt;getReturnType();

        if ($returnType !== null) {
            $signature .= ': ' . $this-&gt;type($returnType);
        }

        return $signature;
    }

    /**
     * @psalm-param Identifier|Name|ComplexType $type
     */
    private function type(Node $type): string
    {
        assert($type instanceof Identifier || $type instanceof Name || $type instanceof ComplexType);

        if ($type instanceof NullableType) {
            return '?' . $type-&gt;type;
        }

        if ($type instanceof UnionType) {
            return $this-&gt;unionTypeAsString($type);
        }

        if ($type instanceof IntersectionType) {
            return $this-&gt;intersectionTypeAsString($type);
        }

        return $type-&gt;toString();
    }

    private function visibility(ClassMethod $node): string
    {
        if ($node-&gt;isPrivate()) {
            return 'private';
        }

        if ($node-&gt;isProtected()) {
            return 'protected';
        }

        return 'public';
    }

    private function processClass(Class_ $node): void
    {
        $name           = $node-&gt;name-&gt;toString();
        $namespacedName = $node-&gt;namespacedName-&gt;toString();

        $this-&gt;classes[$namespacedName] = [
            'name'           =&gt; $name,
            'namespacedName' =&gt; $namespacedName,
            'namespace'      =&gt; $this-&gt;namespace($namespacedName, $name),
            'startLine'      =&gt; $node-&gt;getStartLine(),
            'endLine'        =&gt; $node-&gt;getEndLine(),
            'methods'        =&gt; [],
        ];
    }

    private function processTrait(Trait_ $node): void
    {
        $name           = $node-&gt;name-&gt;toString();
        $namespacedName = $node-&gt;namespacedName-&gt;toString();

        $this-&gt;traits[$namespacedName] = [
            'name'           =&gt; $name,
            'namespacedName' =&gt; $namespacedName,
            'namespace'      =&gt; $this-&gt;namespace($namespacedName, $name),
            'startLine'      =&gt; $node-&gt;getStartLine(),
            'endLine'        =&gt; $node-&gt;getEndLine(),
            'methods'        =&gt; [],
        ];
    }

    private function processMethod(ClassMethod $node): void
    {
        $parentNode = $node-&gt;getAttribute('parent');

        if ($parentNode instanceof Interface_) {
            return;
        }

        assert($parentNode instanceof Class_ || $parentNode instanceof Trait_ || $parentNode instanceof Enum_);
        assert(isset($parentNode-&gt;name));
        assert(isset($parentNode-&gt;namespacedName));
        assert($parentNode-&gt;namespacedName instanceof Name);

        $parentName           = $parentNode-&gt;name-&gt;toString();
        $parentNamespacedName = $parentNode-&gt;namespacedName-&gt;toString();

        if ($parentNode instanceof Class_) {
            $storage = &amp;$this-&gt;classes;
        } else {
            $storage = &amp;$this-&gt;traits;
        }

        if (!isset($storage[$parentNamespacedName])) {
            $storage[$parentNamespacedName] = [
                'name'           =&gt; $parentName,
                'namespacedName' =&gt; $parentNamespacedName,
                'namespace'      =&gt; $this-&gt;namespace($parentNamespacedName, $parentName),
                'startLine'      =&gt; $parentNode-&gt;getStartLine(),
                'endLine'        =&gt; $parentNode-&gt;getEndLine(),
                'methods'        =&gt; [],
            ];
        }

        $storage[$parentNamespacedName]['methods'][$node-&gt;name-&gt;toString()] = [
            'methodName' =&gt; $node-&gt;name-&gt;toString(),
            'signature'  =&gt; $this-&gt;signature($node),
            'visibility' =&gt; $this-&gt;visibility($node),
            'startLine'  =&gt; $node-&gt;getStartLine(),
            'endLine'    =&gt; $node-&gt;getEndLine(),
            'ccn'        =&gt; $this-&gt;cyclomaticComplexity($node),
        ];
    }

    private function processFunction(Function_ $node): void
    {
        assert(isset($node-&gt;name));
        assert(isset($node-&gt;namespacedName));
        assert($node-&gt;namespacedName instanceof Name);

        $name           = $node-&gt;name-&gt;toString();
        $namespacedName = $node-&gt;namespacedName-&gt;toString();

        $this-&gt;functions[$namespacedName] = [
            'name'           =&gt; $name,
            'namespacedName' =&gt; $namespacedName,
            'namespace'      =&gt; $this-&gt;namespace($namespacedName, $name),
            'signature'      =&gt; $this-&gt;signature($node),
            'startLine'      =&gt; $node-&gt;getStartLine(),
            'endLine'        =&gt; $node-&gt;getEndLine(),
            'ccn'            =&gt; $this-&gt;cyclomaticComplexity($node),
        ];
    }

    private function namespace(string $namespacedName, string $name): string
    {
        return trim(rtrim($namespacedName, $name), '\\');
    }

    private function unionTypeAsString(UnionType $node): string
    {
        $types = [];

        foreach ($node-&gt;types as $type) {
            if ($type instanceof IntersectionType) {
                $types[] = '(' . $this-&gt;intersectionTypeAsString($type) . ')';

                continue;
            }

            $types[] = $this-&gt;typeAsString($type);
        }

        return implode('|', $types);
    }

    private function intersectionTypeAsString(IntersectionType $node): string
    {
        $types = [];

        foreach ($node-&gt;types as $type) {
            $types[] = $this-&gt;typeAsString($type);
        }

        return implode('&amp;', $types);
    }

    /**
     * @psalm-param Identifier|Name $node $node
     */
    private function typeAsString(NodeAbstract $node): string
    {
        if ($node instanceof Name) {
            return $node-&gt;toCodeString();
        }

        return $node-&gt;toString();
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>