<form method="POST">
    <h3>Editing: Directory.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_merge;
use function count;
use IteratorAggregate;
use RecursiveIteratorIterator;

/**
 * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
 */
final class Directory extends AbstractNode implements IteratorAggregate
{
    /**
     * @var AbstractNode[]
     */
    private $children = [];

    /**
     * @var Directory[]
     */
    private $directories = [];

    /**
     * @var File[]
     */
    private $files = [];

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

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

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

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

    /**
     * @var int
     */
    private $numFiles = -1;

    /**
     * @var int
     */
    private $numExecutableLines = -1;

    /**
     * @var int
     */
    private $numExecutedLines = -1;

    /**
     * @var int
     */
    private $numExecutableBranches = -1;

    /**
     * @var int
     */
    private $numExecutedBranches = -1;

    /**
     * @var int
     */
    private $numExecutablePaths = -1;

    /**
     * @var int
     */
    private $numExecutedPaths = -1;

    /**
     * @var int
     */
    private $numClasses = -1;

    /**
     * @var int
     */
    private $numTestedClasses = -1;

    /**
     * @var int
     */
    private $numTraits = -1;

    /**
     * @var int
     */
    private $numTestedTraits = -1;

    /**
     * @var int
     */
    private $numMethods = -1;

    /**
     * @var int
     */
    private $numTestedMethods = -1;

    /**
     * @var int
     */
    private $numFunctions = -1;

    /**
     * @var int
     */
    private $numTestedFunctions = -1;

    public function count(): int
    {
        if ($this-&gt;numFiles === -1) {
            $this-&gt;numFiles = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numFiles += count($child);
            }
        }

        return $this-&gt;numFiles;
    }

    public function getIterator(): RecursiveIteratorIterator
    {
        return new RecursiveIteratorIterator(
            new Iterator($this),
            RecursiveIteratorIterator::SELF_FIRST
        );
    }

    public function addDirectory(string $name): self
    {
        $directory = new self($name, $this);

        $this-&gt;children[]    = $directory;
        $this-&gt;directories[] = &amp;$this-&gt;children[count($this-&gt;children) - 1];

        return $directory;
    }

    public function addFile(File $file): void
    {
        $this-&gt;children[] = $file;
        $this-&gt;files[]    = &amp;$this-&gt;children[count($this-&gt;children) - 1];

        $this-&gt;numExecutableLines = -1;
        $this-&gt;numExecutedLines   = -1;
    }

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

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

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

    public function classes(): array
    {
        if ($this-&gt;classes === null) {
            $this-&gt;classes = [];

            foreach ($this-&gt;children as $child) {
                $this-&gt;classes = array_merge(
                    $this-&gt;classes,
                    $child-&gt;classes()
                );
            }
        }

        return $this-&gt;classes;
    }

    public function traits(): array
    {
        if ($this-&gt;traits === null) {
            $this-&gt;traits = [];

            foreach ($this-&gt;children as $child) {
                $this-&gt;traits = array_merge(
                    $this-&gt;traits,
                    $child-&gt;traits()
                );
            }
        }

        return $this-&gt;traits;
    }

    public function functions(): array
    {
        if ($this-&gt;functions === null) {
            $this-&gt;functions = [];

            foreach ($this-&gt;children as $child) {
                $this-&gt;functions = array_merge(
                    $this-&gt;functions,
                    $child-&gt;functions()
                );
            }
        }

        return $this-&gt;functions;
    }

    /**
     * @psalm-return array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int}
     */
    public function linesOfCode(): array
    {
        if ($this-&gt;linesOfCode === null) {
            $this-&gt;linesOfCode = [
                'linesOfCode'           =&gt; 0,
                'commentLinesOfCode'    =&gt; 0,
                'nonCommentLinesOfCode' =&gt; 0,
            ];

            foreach ($this-&gt;children as $child) {
                $childLinesOfCode = $child-&gt;linesOfCode();

                $this-&gt;linesOfCode['linesOfCode'] += $childLinesOfCode['linesOfCode'];
                $this-&gt;linesOfCode['commentLinesOfCode'] += $childLinesOfCode['commentLinesOfCode'];
                $this-&gt;linesOfCode['nonCommentLinesOfCode'] += $childLinesOfCode['nonCommentLinesOfCode'];
            }
        }

        return $this-&gt;linesOfCode;
    }

    public function numberOfExecutableLines(): int
    {
        if ($this-&gt;numExecutableLines === -1) {
            $this-&gt;numExecutableLines = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numExecutableLines += $child-&gt;numberOfExecutableLines();
            }
        }

        return $this-&gt;numExecutableLines;
    }

    public function numberOfExecutedLines(): int
    {
        if ($this-&gt;numExecutedLines === -1) {
            $this-&gt;numExecutedLines = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numExecutedLines += $child-&gt;numberOfExecutedLines();
            }
        }

        return $this-&gt;numExecutedLines;
    }

    public function numberOfExecutableBranches(): int
    {
        if ($this-&gt;numExecutableBranches === -1) {
            $this-&gt;numExecutableBranches = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numExecutableBranches += $child-&gt;numberOfExecutableBranches();
            }
        }

        return $this-&gt;numExecutableBranches;
    }

    public function numberOfExecutedBranches(): int
    {
        if ($this-&gt;numExecutedBranches === -1) {
            $this-&gt;numExecutedBranches = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numExecutedBranches += $child-&gt;numberOfExecutedBranches();
            }
        }

        return $this-&gt;numExecutedBranches;
    }

    public function numberOfExecutablePaths(): int
    {
        if ($this-&gt;numExecutablePaths === -1) {
            $this-&gt;numExecutablePaths = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numExecutablePaths += $child-&gt;numberOfExecutablePaths();
            }
        }

        return $this-&gt;numExecutablePaths;
    }

    public function numberOfExecutedPaths(): int
    {
        if ($this-&gt;numExecutedPaths === -1) {
            $this-&gt;numExecutedPaths = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numExecutedPaths += $child-&gt;numberOfExecutedPaths();
            }
        }

        return $this-&gt;numExecutedPaths;
    }

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

            foreach ($this-&gt;children as $child) {
                $this-&gt;numClasses += $child-&gt;numberOfClasses();
            }
        }

        return $this-&gt;numClasses;
    }

    public function numberOfTestedClasses(): int
    {
        if ($this-&gt;numTestedClasses === -1) {
            $this-&gt;numTestedClasses = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numTestedClasses += $child-&gt;numberOfTestedClasses();
            }
        }

        return $this-&gt;numTestedClasses;
    }

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

            foreach ($this-&gt;children as $child) {
                $this-&gt;numTraits += $child-&gt;numberOfTraits();
            }
        }

        return $this-&gt;numTraits;
    }

    public function numberOfTestedTraits(): int
    {
        if ($this-&gt;numTestedTraits === -1) {
            $this-&gt;numTestedTraits = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numTestedTraits += $child-&gt;numberOfTestedTraits();
            }
        }

        return $this-&gt;numTestedTraits;
    }

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

            foreach ($this-&gt;children as $child) {
                $this-&gt;numMethods += $child-&gt;numberOfMethods();
            }
        }

        return $this-&gt;numMethods;
    }

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

            foreach ($this-&gt;children as $child) {
                $this-&gt;numTestedMethods += $child-&gt;numberOfTestedMethods();
            }
        }

        return $this-&gt;numTestedMethods;
    }

    public function numberOfFunctions(): int
    {
        if ($this-&gt;numFunctions === -1) {
            $this-&gt;numFunctions = 0;

            foreach ($this-&gt;children as $child) {
                $this-&gt;numFunctions += $child-&gt;numberOfFunctions();
            }
        }

        return $this-&gt;numFunctions;
    }

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

            foreach ($this-&gt;children as $child) {
                $this-&gt;numTestedFunctions += $child-&gt;numberOfTestedFunctions();
            }
        }

        return $this-&gt;numTestedFunctions;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>