<form method="POST">
    <h3>Editing: File.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\Node;

use function array_filter;
use function count;
use function range;

/**
 * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
 */
final class File extends AbstractNode
{
    /**
     * @var array
     */
    private $lineCoverageData;

    /**
     * @var array
     */
    private $functionCoverageData;

    /**
     * @var array
     */
    private $testData;

    /**
     * @var int
     */
    private $numExecutableLines = 0;

    /**
     * @var int
     */
    private $numExecutedLines = 0;

    /**
     * @var int
     */
    private $numExecutableBranches = 0;

    /**
     * @var int
     */
    private $numExecutedBranches = 0;

    /**
     * @var int
     */
    private $numExecutablePaths = 0;

    /**
     * @var int
     */
    private $numExecutedPaths = 0;

    /**
     * @var array
     */
    private $classes = [];

    /**
     * @var array
     */
    private $traits = [];

    /**
     * @var array
     */
    private $functions = [];

    /**
     * @psalm-var array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int}
     */
    private $linesOfCode;

    /**
     * @var int
     */
    private $numClasses;

    /**
     * @var int
     */
    private $numTestedClasses = 0;

    /**
     * @var int
     */
    private $numTraits;

    /**
     * @var int
     */
    private $numTestedTraits = 0;

    /**
     * @var int
     */
    private $numMethods;

    /**
     * @var int
     */
    private $numTestedMethods;

    /**
     * @var int
     */
    private $numTestedFunctions;

    /**
     * @var array
     */
    private $codeUnitsByLine = [];

    /**
     * @psalm-param array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int} $linesOfCode
     */
    public function __construct(string $name, AbstractNode $parent, array $lineCoverageData, array $functionCoverageData, array $testData, array $classes, array $traits, array $functions, array $linesOfCode)
    {
        parent::__construct($name, $parent);

        $this-&gt;lineCoverageData     = $lineCoverageData;
        $this-&gt;functionCoverageData = $functionCoverageData;
        $this-&gt;testData             = $testData;
        $this-&gt;linesOfCode          = $linesOfCode;

        $this-&gt;calculateStatistics($classes, $traits, $functions);
    }

    public function count(): int
    {
        return 1;
    }

    public function lineCoverageData(): array
    {
        return $this-&gt;lineCoverageData;
    }

    public function functionCoverageData(): array
    {
        return $this-&gt;functionCoverageData;
    }

    public function testData(): array
    {
        return $this-&gt;testData;
    }

    public function classes(): array
    {
        return $this-&gt;classes;
    }

    public function traits(): array
    {
        return $this-&gt;traits;
    }

    public function functions(): array
    {
        return $this-&gt;functions;
    }

    /**
     * @psalm-return array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int}
     */
    public function linesOfCode(): array
    {
        return $this-&gt;linesOfCode;
    }

    public function numberOfExecutableLines(): int
    {
        return $this-&gt;numExecutableLines;
    }

    public function numberOfExecutedLines(): int
    {
        return $this-&gt;numExecutedLines;
    }

    public function numberOfExecutableBranches(): int
    {
        return $this-&gt;numExecutableBranches;
    }

    public function numberOfExecutedBranches(): int
    {
        return $this-&gt;numExecutedBranches;
    }

    public function numberOfExecutablePaths(): int
    {
        return $this-&gt;numExecutablePaths;
    }

    public function numberOfExecutedPaths(): int
    {
        return $this-&gt;numExecutedPaths;
    }

    public function numberOfClasses(): int
    {
        if ($this-&gt;numClasses === null) {
            $this-&gt;numClasses = 0;

            foreach ($this-&gt;classes as $class) {
                foreach ($class['methods'] as $method) {
                    if ($method['executableLines'] &gt; 0) {
                        $this-&gt;numClasses++;

                        continue 2;
                    }
                }
            }
        }

        return $this-&gt;numClasses;
    }

    public function numberOfTestedClasses(): int
    {
        return $this-&gt;numTestedClasses;
    }

    public function numberOfTraits(): int
    {
        if ($this-&gt;numTraits === null) {
            $this-&gt;numTraits = 0;

            foreach ($this-&gt;traits as $trait) {
                foreach ($trait['methods'] as $method) {
                    if ($method['executableLines'] &gt; 0) {
                        $this-&gt;numTraits++;

                        continue 2;
                    }
                }
            }
        }

        return $this-&gt;numTraits;
    }

    public function numberOfTestedTraits(): int
    {
        return $this-&gt;numTestedTraits;
    }

    public function numberOfMethods(): int
    {
        if ($this-&gt;numMethods === null) {
            $this-&gt;numMethods = 0;

            foreach ($this-&gt;classes as $class) {
                foreach ($class['methods'] as $method) {
                    if ($method['executableLines'] &gt; 0) {
                        $this-&gt;numMethods++;
                    }
                }
            }

            foreach ($this-&gt;traits as $trait) {
                foreach ($trait['methods'] as $method) {
                    if ($method['executableLines'] &gt; 0) {
                        $this-&gt;numMethods++;
                    }
                }
            }
        }

        return $this-&gt;numMethods;
    }

    public function numberOfTestedMethods(): int
    {
        if ($this-&gt;numTestedMethods === null) {
            $this-&gt;numTestedMethods = 0;

            foreach ($this-&gt;classes as $class) {
                foreach ($class['methods'] as $method) {
                    if ($method['executableLines'] &gt; 0 &amp;&amp;
                        $method['coverage'] === 100) {
                        $this-&gt;numTestedMethods++;
                    }
                }
            }

            foreach ($this-&gt;traits as $trait) {
                foreach ($trait['methods'] as $method) {
                    if ($method['executableLines'] &gt; 0 &amp;&amp;
                        $method['coverage'] === 100) {
                        $this-&gt;numTestedMethods++;
                    }
                }
            }
        }

        return $this-&gt;numTestedMethods;
    }

    public function numberOfFunctions(): int
    {
        return count($this-&gt;functions);
    }

    public function numberOfTestedFunctions(): int
    {
        if ($this-&gt;numTestedFunctions === null) {
            $this-&gt;numTestedFunctions = 0;

            foreach ($this-&gt;functions as $function) {
                if ($function['executableLines'] &gt; 0 &amp;&amp;
                    $function['coverage'] === 100) {
                    $this-&gt;numTestedFunctions++;
                }
            }
        }

        return $this-&gt;numTestedFunctions;
    }

    private function calculateStatistics(array $classes, array $traits, array $functions): void
    {
        foreach (range(1, $this-&gt;linesOfCode['linesOfCode']) as $lineNumber) {
            $this-&gt;codeUnitsByLine[$lineNumber] = [];
        }

        $this-&gt;processClasses($classes);
        $this-&gt;processTraits($traits);
        $this-&gt;processFunctions($functions);

        foreach (range(1, $this-&gt;linesOfCode['linesOfCode']) as $lineNumber) {
            if (isset($this-&gt;lineCoverageData[$lineNumber])) {
                foreach ($this-&gt;codeUnitsByLine[$lineNumber] as &amp;$codeUnit) {
                    $codeUnit['executableLines']++;
                }

                unset($codeUnit);

                $this-&gt;numExecutableLines++;

                if (count($this-&gt;lineCoverageData[$lineNumber]) &gt; 0) {
                    foreach ($this-&gt;codeUnitsByLine[$lineNumber] as &amp;$codeUnit) {
                        $codeUnit['executedLines']++;
                    }

                    unset($codeUnit);

                    $this-&gt;numExecutedLines++;
                }
            }
        }

        foreach ($this-&gt;traits as &amp;$trait) {
            foreach ($trait['methods'] as &amp;$method) {
                $methodLineCoverage   = $method['executableLines'] ? ($method['executedLines'] / $method['executableLines']) * 100 : 100;
                $methodBranchCoverage = $method['executableBranches'] ? ($method['executedBranches'] / $method['executableBranches']) * 100 : 0;
                $methodPathCoverage   = $method['executablePaths'] ? ($method['executedPaths'] / $method['executablePaths']) * 100 : 0;

                $method['coverage'] = $methodBranchCoverage ?: $methodLineCoverage;
                $method['crap']     = (new CrapIndex($method['ccn'], $methodPathCoverage ?: $methodLineCoverage))-&gt;asString();

                $trait['ccn'] += $method['ccn'];
            }

            unset($method);

            $traitLineCoverage   = $trait['executableLines'] ? ($trait['executedLines'] / $trait['executableLines']) * 100 : 100;
            $traitBranchCoverage = $trait['executableBranches'] ? ($trait['executedBranches'] / $trait['executableBranches']) * 100 : 0;
            $traitPathCoverage   = $trait['executablePaths'] ? ($trait['executedPaths'] / $trait['executablePaths']) * 100 : 0;

            $trait['coverage'] = $traitBranchCoverage ?: $traitLineCoverage;
            $trait['crap']     = (new CrapIndex($trait['ccn'], $traitPathCoverage ?: $traitLineCoverage))-&gt;asString();

            if ($trait['executableLines'] &gt; 0 &amp;&amp; $trait['coverage'] === 100) {
                $this-&gt;numTestedClasses++;
            }
        }

        unset($trait);

        foreach ($this-&gt;classes as &amp;$class) {
            foreach ($class['methods'] as &amp;$method) {
                $methodLineCoverage   = $method['executableLines'] ? ($method['executedLines'] / $method['executableLines']) * 100 : 100;
                $methodBranchCoverage = $method['executableBranches'] ? ($method['executedBranches'] / $method['executableBranches']) * 100 : 0;
                $methodPathCoverage   = $method['executablePaths'] ? ($method['executedPaths'] / $method['executablePaths']) * 100 : 0;

                $method['coverage'] = $methodBranchCoverage ?: $methodLineCoverage;
                $method['crap']     = (new CrapIndex($method['ccn'], $methodPathCoverage ?: $methodLineCoverage))-&gt;asString();

                $class['ccn'] += $method['ccn'];
            }

            unset($method);

            $classLineCoverage   = $class['executableLines'] ? ($class['executedLines'] / $class['executableLines']) * 100 : 100;
            $classBranchCoverage = $class['executableBranches'] ? ($class['executedBranches'] / $class['executableBranches']) * 100 : 0;
            $classPathCoverage   = $class['executablePaths'] ? ($class['executedPaths'] / $class['executablePaths']) * 100 : 0;

            $class['coverage'] = $classBranchCoverage ?: $classLineCoverage;
            $class['crap']     = (new CrapIndex($class['ccn'], $classPathCoverage ?: $classLineCoverage))-&gt;asString();

            if ($class['executableLines'] &gt; 0 &amp;&amp; $class['coverage'] === 100) {
                $this-&gt;numTestedClasses++;
            }
        }

        unset($class);

        foreach ($this-&gt;functions as &amp;$function) {
            $functionLineCoverage   = $function['executableLines'] ? ($function['executedLines'] / $function['executableLines']) * 100 : 100;
            $functionBranchCoverage = $function['executableBranches'] ? ($function['executedBranches'] / $function['executableBranches']) * 100 : 0;
            $functionPathCoverage   = $function['executablePaths'] ? ($function['executedPaths'] / $function['executablePaths']) * 100 : 0;

            $function['coverage'] = $functionBranchCoverage ?: $functionLineCoverage;
            $function['crap']     = (new CrapIndex($function['ccn'], $functionPathCoverage ?: $functionLineCoverage))-&gt;asString();

            if ($function['coverage'] === 100) {
                $this-&gt;numTestedFunctions++;
            }
        }
    }

    private function processClasses(array $classes): void
    {
        $link = $this-&gt;id() . '.html#';

        foreach ($classes as $className =&gt; $class) {
            $this-&gt;classes[$className] = [
                'className'          =&gt; $className,
                'namespace'          =&gt; $class['namespace'],
                'methods'            =&gt; [],
                'startLine'          =&gt; $class['startLine'],
                'executableLines'    =&gt; 0,
                'executedLines'      =&gt; 0,
                'executableBranches' =&gt; 0,
                'executedBranches'   =&gt; 0,
                'executablePaths'    =&gt; 0,
                'executedPaths'      =&gt; 0,
                'ccn'                =&gt; 0,
                'coverage'           =&gt; 0,
                'crap'               =&gt; 0,
                'link'               =&gt; $link . $class['startLine'],
            ];

            foreach ($class['methods'] as $methodName =&gt; $method) {
                $methodData                                        = $this-&gt;newMethod($className, $methodName, $method, $link);
                $this-&gt;classes[$className]['methods'][$methodName] = $methodData;

                $this-&gt;classes[$className]['executableBranches'] += $methodData['executableBranches'];
                $this-&gt;classes[$className]['executedBranches'] += $methodData['executedBranches'];
                $this-&gt;classes[$className]['executablePaths'] += $methodData['executablePaths'];
                $this-&gt;classes[$className]['executedPaths'] += $methodData['executedPaths'];

                $this-&gt;numExecutableBranches += $methodData['executableBranches'];
                $this-&gt;numExecutedBranches += $methodData['executedBranches'];
                $this-&gt;numExecutablePaths += $methodData['executablePaths'];
                $this-&gt;numExecutedPaths += $methodData['executedPaths'];

                foreach (range($method['startLine'], $method['endLine']) as $lineNumber) {
                    $this-&gt;codeUnitsByLine[$lineNumber] = [
                        &amp;$this-&gt;classes[$className],
                        &amp;$this-&gt;classes[$className]['methods'][$methodName],
                    ];
                }
            }
        }
    }

    private function processTraits(array $traits): void
    {
        $link = $this-&gt;id() . '.html#';

        foreach ($traits as $traitName =&gt; $trait) {
            $this-&gt;traits[$traitName] = [
                'traitName'          =&gt; $traitName,
                'namespace'          =&gt; $trait['namespace'],
                'methods'            =&gt; [],
                'startLine'          =&gt; $trait['startLine'],
                'executableLines'    =&gt; 0,
                'executedLines'      =&gt; 0,
                'executableBranches' =&gt; 0,
                'executedBranches'   =&gt; 0,
                'executablePaths'    =&gt; 0,
                'executedPaths'      =&gt; 0,
                'ccn'                =&gt; 0,
                'coverage'           =&gt; 0,
                'crap'               =&gt; 0,
                'link'               =&gt; $link . $trait['startLine'],
            ];

            foreach ($trait['methods'] as $methodName =&gt; $method) {
                $methodData                                       = $this-&gt;newMethod($traitName, $methodName, $method, $link);
                $this-&gt;traits[$traitName]['methods'][$methodName] = $methodData;

                $this-&gt;traits[$traitName]['executableBranches'] += $methodData['executableBranches'];
                $this-&gt;traits[$traitName]['executedBranches'] += $methodData['executedBranches'];
                $this-&gt;traits[$traitName]['executablePaths'] += $methodData['executablePaths'];
                $this-&gt;traits[$traitName]['executedPaths'] += $methodData['executedPaths'];

                $this-&gt;numExecutableBranches += $methodData['executableBranches'];
                $this-&gt;numExecutedBranches += $methodData['executedBranches'];
                $this-&gt;numExecutablePaths += $methodData['executablePaths'];
                $this-&gt;numExecutedPaths += $methodData['executedPaths'];

                foreach (range($method['startLine'], $method['endLine']) as $lineNumber) {
                    $this-&gt;codeUnitsByLine[$lineNumber] = [
                        &amp;$this-&gt;traits[$traitName],
                        &amp;$this-&gt;traits[$traitName]['methods'][$methodName],
                    ];
                }
            }
        }
    }

    private function processFunctions(array $functions): void
    {
        $link = $this-&gt;id() . '.html#';

        foreach ($functions as $functionName =&gt; $function) {
            $this-&gt;functions[$functionName] = [
                'functionName'       =&gt; $functionName,
                'namespace'          =&gt; $function['namespace'],
                'signature'          =&gt; $function['signature'],
                'startLine'          =&gt; $function['startLine'],
                'endLine'            =&gt; $function['endLine'],
                'executableLines'    =&gt; 0,
                'executedLines'      =&gt; 0,
                'executableBranches' =&gt; 0,
                'executedBranches'   =&gt; 0,
                'executablePaths'    =&gt; 0,
                'executedPaths'      =&gt; 0,
                'ccn'                =&gt; $function['ccn'],
                'coverage'           =&gt; 0,
                'crap'               =&gt; 0,
                'link'               =&gt; $link . $function['startLine'],
            ];

            foreach (range($function['startLine'], $function['endLine']) as $lineNumber) {
                $this-&gt;codeUnitsByLine[$lineNumber] = [&amp;$this-&gt;functions[$functionName]];
            }

            if (isset($this-&gt;functionCoverageData[$functionName]['branches'])) {
                $this-&gt;functions[$functionName]['executableBranches'] = count(
                    $this-&gt;functionCoverageData[$functionName]['branches']
                );

                $this-&gt;functions[$functionName]['executedBranches'] = count(
                    array_filter(
                        $this-&gt;functionCoverageData[$functionName]['branches'],
                        static function (array $branch)
                        {
                            return (bool) $branch['hit'];
                        }
                    )
                );
            }

            if (isset($this-&gt;functionCoverageData[$functionName]['paths'])) {
                $this-&gt;functions[$functionName]['executablePaths'] = count(
                    $this-&gt;functionCoverageData[$functionName]['paths']
                );

                $this-&gt;functions[$functionName]['executedPaths'] = count(
                    array_filter(
                        $this-&gt;functionCoverageData[$functionName]['paths'],
                        static function (array $path)
                        {
                            return (bool) $path['hit'];
                        }
                    )
                );
            }

            $this-&gt;numExecutableBranches += $this-&gt;functions[$functionName]['executableBranches'];
            $this-&gt;numExecutedBranches += $this-&gt;functions[$functionName]['executedBranches'];
            $this-&gt;numExecutablePaths += $this-&gt;functions[$functionName]['executablePaths'];
            $this-&gt;numExecutedPaths += $this-&gt;functions[$functionName]['executedPaths'];
        }
    }

    private function newMethod(string $className, string $methodName, array $method, string $link): array
    {
        $methodData = [
            'methodName'         =&gt; $methodName,
            'visibility'         =&gt; $method['visibility'],
            'signature'          =&gt; $method['signature'],
            'startLine'          =&gt; $method['startLine'],
            'endLine'            =&gt; $method['endLine'],
            'executableLines'    =&gt; 0,
            'executedLines'      =&gt; 0,
            'executableBranches' =&gt; 0,
            'executedBranches'   =&gt; 0,
            'executablePaths'    =&gt; 0,
            'executedPaths'      =&gt; 0,
            'ccn'                =&gt; $method['ccn'],
            'coverage'           =&gt; 0,
            'crap'               =&gt; 0,
            'link'               =&gt; $link . $method['startLine'],
        ];

        $key = $className . '-&gt;' . $methodName;

        if (isset($this-&gt;functionCoverageData[$key]['branches'])) {
            $methodData['executableBranches'] = count(
                $this-&gt;functionCoverageData[$key]['branches']
            );

            $methodData['executedBranches'] = count(
                array_filter(
                    $this-&gt;functionCoverageData[$key]['branches'],
                    static function (array $branch)
                    {
                        return (bool) $branch['hit'];
                    }
                )
            );
        }

        if (isset($this-&gt;functionCoverageData[$key]['paths'])) {
            $methodData['executablePaths'] = count(
                $this-&gt;functionCoverageData[$key]['paths']
            );

            $methodData['executedPaths'] = count(
                array_filter(
                    $this-&gt;functionCoverageData[$key]['paths'],
                    static function (array $path)
                    {
                        return (bool) $path['hit'];
                    }
                )
            );
        }

        return $methodData;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>