<form method="POST">
    <h3>Editing: TimeitCommand.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of Psy Shell.
 *
 * (c) 2012-2023 Justin Hileman
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Psy\Command;

use PhpParser\NodeTraverser;
use PhpParser\PrettyPrinter\Standard as Printer;
use Psy\Command\TimeitCommand\TimeitVisitor;
use Psy\Input\CodeArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class TimeitCommand.
 */
class TimeitCommand extends Command
{
    const RESULT_MSG = '&lt;info&gt;Command took %.6f seconds to complete.&lt;/info&gt;';
    const AVG_RESULT_MSG = '&lt;info&gt;Command took %.6f seconds on average (%.6f median; %.6f total) to complete.&lt;/info&gt;';

    // All times stored as nanoseconds!
    private static $start = null;
    private static $times = [];

    private $parser;
    private $traverser;
    private $printer;

    /**
     * {@inheritdoc}
     */
    public function __construct($name = null)
    {
        $this-&gt;parser = new CodeArgumentParser();

        // @todo Pass visitor directly to once we drop support for PHP-Parser 4.x
        $this-&gt;traverser = new NodeTraverser();
        $this-&gt;traverser-&gt;addVisitor(new TimeitVisitor());

        $this-&gt;printer = new Printer();

        parent::__construct($name);
    }

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this
            -&gt;setName('timeit')
            -&gt;setDefinition([
                new InputOption('num', 'n', InputOption::VALUE_REQUIRED, 'Number of iterations.'),
                new CodeArgument('code', CodeArgument::REQUIRED, 'Code to execute.'),
            ])
            -&gt;setDescription('Profiles with a timer.')
            -&gt;setHelp(
                &lt;&lt;&lt;'HELP'
Time profiling for functions and commands.

e.g.
&lt;return&gt;&gt;&gt;&gt; timeit sleep(1)&lt;/return&gt;
&lt;return&gt;&gt;&gt;&gt; timeit -n1000 $closure()&lt;/return&gt;
HELP
            );
    }

    /**
     * {@inheritdoc}
     *
     * @return int 0 if everything went fine, or an exit code
     */
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $code = $input-&gt;getArgument('code');
        $num = (int) ($input-&gt;getOption('num') ?: 1);
        $shell = $this-&gt;getApplication();

        $instrumentedCode = $this-&gt;instrumentCode($code);

        self::$times = [];

        do {
            $_ = $shell-&gt;execute($instrumentedCode);
            $this-&gt;ensureEndMarked();
        } while (\count(self::$times) &lt; $num);

        $shell-&gt;writeReturnValue($_);

        $times = self::$times;
        self::$times = [];

        if ($num === 1) {
            $output-&gt;writeln(\sprintf(self::RESULT_MSG, $times[0] / 1e+9));
        } else {
            $total = \array_sum($times);
            \rsort($times);
            $median = $times[\round($num / 2)];

            $output-&gt;writeln(\sprintf(self::AVG_RESULT_MSG, ($total / $num) / 1e+9, $median / 1e+9, $total / 1e+9));
        }

        return 0;
    }

    /**
     * Internal method for marking the start of timeit execution.
     *
     * A static call to this method will be injected at the start of the timeit
     * input code to instrument the call. We will use the saved start time to
     * more accurately calculate time elapsed during execution.
     */
    public static function markStart()
    {
        self::$start = \hrtime(true);
    }

    /**
     * Internal method for marking the end of timeit execution.
     *
     * A static call to this method is injected by TimeitVisitor at the end
     * of the timeit input code to instrument the call.
     *
     * Note that this accepts an optional $ret parameter, which is used to pass
     * the return value of the last statement back out of timeit. This saves us
     * a bunch of code rewriting shenanigans.
     *
     * @param mixed $ret
     *
     * @return mixed it just passes $ret right back
     */
    public static function markEnd($ret = null)
    {
        self::$times[] = \hrtime(true) - self::$start;
        self::$start = null;

        return $ret;
    }

    /**
     * Ensure that the end of code execution was marked.
     *
     * The end *should* be marked in the instrumented code, but just in case
     * we'll add a fallback here.
     */
    private function ensureEndMarked()
    {
        if (self::$start !== null) {
            self::markEnd();
        }
    }

    /**
     * Instrument code for timeit execution.
     *
     * This inserts `markStart` and `markEnd` calls to ensure that (reasonably)
     * accurate times are recorded for just the code being executed.
     */
    private function instrumentCode(string $code): string
    {
        return $this-&gt;printer-&gt;prettyPrint($this-&gt;traverser-&gt;traverse($this-&gt;parser-&gt;parse($code)));
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>