<form method="POST">
    <h3>Editing: Emulative.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

namespace PhpParser\Lexer;

use PhpParser\Error;
use PhpParser\ErrorHandler;
use PhpParser\Lexer;
use PhpParser\Lexer\TokenEmulator\AttributeEmulator;
use PhpParser\Lexer\TokenEmulator\EnumTokenEmulator;
use PhpParser\Lexer\TokenEmulator\CoaleseEqualTokenEmulator;
use PhpParser\Lexer\TokenEmulator\ExplicitOctalEmulator;
use PhpParser\Lexer\TokenEmulator\FlexibleDocStringEmulator;
use PhpParser\Lexer\TokenEmulator\FnTokenEmulator;
use PhpParser\Lexer\TokenEmulator\MatchTokenEmulator;
use PhpParser\Lexer\TokenEmulator\NullsafeTokenEmulator;
use PhpParser\Lexer\TokenEmulator\NumericLiteralSeparatorEmulator;
use PhpParser\Lexer\TokenEmulator\ReadonlyFunctionTokenEmulator;
use PhpParser\Lexer\TokenEmulator\ReadonlyTokenEmulator;
use PhpParser\Lexer\TokenEmulator\ReverseEmulator;
use PhpParser\Lexer\TokenEmulator\TokenEmulator;
use PhpParser\PhpVersion;
use PhpParser\Token;

class Emulative extends Lexer {
    /** @var array{int, string, string}[] Patches used to reverse changes introduced in the code */
    private array $patches = [];

    /** @var list&lt;TokenEmulator&gt; */
    private array $emulators = [];

    private PhpVersion $targetPhpVersion;

    private PhpVersion $hostPhpVersion;

    /**
     * @param PhpVersion|null $phpVersion PHP version to emulate. Defaults to newest supported.
     */
    public function __construct(?PhpVersion $phpVersion = null) {
        $this-&gt;targetPhpVersion = $phpVersion ?? PhpVersion::getNewestSupported();
        $this-&gt;hostPhpVersion = PhpVersion::getHostVersion();

        $emulators = [
            new MatchTokenEmulator(),
            new NullsafeTokenEmulator(),
            new AttributeEmulator(),
            new EnumTokenEmulator(),
            new ReadonlyTokenEmulator(),
            new ExplicitOctalEmulator(),
            new ReadonlyFunctionTokenEmulator(),
        ];

        // Collect emulators that are relevant for the PHP version we're running
        // and the PHP version we're targeting for emulation.
        foreach ($emulators as $emulator) {
            $emulatorPhpVersion = $emulator-&gt;getPhpVersion();
            if ($this-&gt;isForwardEmulationNeeded($emulatorPhpVersion)) {
                $this-&gt;emulators[] = $emulator;
            } elseif ($this-&gt;isReverseEmulationNeeded($emulatorPhpVersion)) {
                $this-&gt;emulators[] = new ReverseEmulator($emulator);
            }
        }
    }

    public function tokenize(string $code, ?ErrorHandler $errorHandler = null): array {
        $emulators = array_filter($this-&gt;emulators, function ($emulator) use ($code) {
            return $emulator-&gt;isEmulationNeeded($code);
        });

        if (empty($emulators)) {
            // Nothing to emulate, yay
            return parent::tokenize($code, $errorHandler);
        }

        if ($errorHandler === null) {
            $errorHandler = new ErrorHandler\Throwing();
        }

        $this-&gt;patches = [];
        foreach ($emulators as $emulator) {
            $code = $emulator-&gt;preprocessCode($code, $this-&gt;patches);
        }

        $collector = new ErrorHandler\Collecting();
        $tokens = parent::tokenize($code, $collector);
        $this-&gt;sortPatches();
        $tokens = $this-&gt;fixupTokens($tokens);

        $errors = $collector-&gt;getErrors();
        if (!empty($errors)) {
            $this-&gt;fixupErrors($errors);
            foreach ($errors as $error) {
                $errorHandler-&gt;handleError($error);
            }
        }

        foreach ($emulators as $emulator) {
            $tokens = $emulator-&gt;emulate($code, $tokens);
        }

        return $tokens;
    }

    private function isForwardEmulationNeeded(PhpVersion $emulatorPhpVersion): bool {
        return $this-&gt;hostPhpVersion-&gt;older($emulatorPhpVersion)
            &amp;&amp; $this-&gt;targetPhpVersion-&gt;newerOrEqual($emulatorPhpVersion);
    }

    private function isReverseEmulationNeeded(PhpVersion $emulatorPhpVersion): bool {
        return $this-&gt;hostPhpVersion-&gt;newerOrEqual($emulatorPhpVersion)
            &amp;&amp; $this-&gt;targetPhpVersion-&gt;older($emulatorPhpVersion);
    }

    private function sortPatches(): void {
        // Patches may be contributed by different emulators.
        // Make sure they are sorted by increasing patch position.
        usort($this-&gt;patches, function ($p1, $p2) {
            return $p1[0] &lt;=&gt; $p2[0];
        });
    }

    /**
     * @param list&lt;Token&gt; $tokens
     * @return list&lt;Token&gt;
     */
    private function fixupTokens(array $tokens): array {
        if (\count($this-&gt;patches) === 0) {
            return $tokens;
        }

        // Load first patch
        $patchIdx = 0;
        list($patchPos, $patchType, $patchText) = $this-&gt;patches[$patchIdx];

        // We use a manual loop over the tokens, because we modify the array on the fly
        $posDelta = 0;
        $lineDelta = 0;
        for ($i = 0, $c = \count($tokens); $i &lt; $c; $i++) {
            $token = $tokens[$i];
            $pos = $token-&gt;pos;
            $token-&gt;pos += $posDelta;
            $token-&gt;line += $lineDelta;
            $localPosDelta = 0;
            $len = \strlen($token-&gt;text);
            while ($patchPos &gt;= $pos &amp;&amp; $patchPos &lt; $pos + $len) {
                $patchTextLen = \strlen($patchText);
                if ($patchType === 'remove') {
                    if ($patchPos === $pos &amp;&amp; $patchTextLen === $len) {
                        // Remove token entirely
                        array_splice($tokens, $i, 1, []);
                        $i--;
                        $c--;
                    } else {
                        // Remove from token string
                        $token-&gt;text = substr_replace(
                            $token-&gt;text, '', $patchPos - $pos + $localPosDelta, $patchTextLen
                        );
                        $localPosDelta -= $patchTextLen;
                    }
                    $lineDelta -= \substr_count($patchText, &quot;\n&quot;);
                } elseif ($patchType === 'add') {
                    // Insert into the token string
                    $token-&gt;text = substr_replace(
                        $token-&gt;text, $patchText, $patchPos - $pos + $localPosDelta, 0
                    );
                    $localPosDelta += $patchTextLen;
                    $lineDelta += \substr_count($patchText, &quot;\n&quot;);
                } elseif ($patchType === 'replace') {
                    // Replace inside the token string
                    $token-&gt;text = substr_replace(
                        $token-&gt;text, $patchText, $patchPos - $pos + $localPosDelta, $patchTextLen
                    );
                } else {
                    assert(false);
                }

                // Fetch the next patch
                $patchIdx++;
                if ($patchIdx &gt;= \count($this-&gt;patches)) {
                    // No more patches. However, we still need to adjust position.
                    $patchPos = \PHP_INT_MAX;
                    break;
                }

                list($patchPos, $patchType, $patchText) = $this-&gt;patches[$patchIdx];
            }

            $posDelta += $localPosDelta;
        }
        return $tokens;
    }

    /**
     * Fixup line and position information in errors.
     *
     * @param Error[] $errors
     */
    private function fixupErrors(array $errors): void {
        foreach ($errors as $error) {
            $attrs = $error-&gt;getAttributes();

            $posDelta = 0;
            $lineDelta = 0;
            foreach ($this-&gt;patches as $patch) {
                list($patchPos, $patchType, $patchText) = $patch;
                if ($patchPos &gt;= $attrs['startFilePos']) {
                    // No longer relevant
                    break;
                }

                if ($patchType === 'add') {
                    $posDelta += strlen($patchText);
                    $lineDelta += substr_count($patchText, &quot;\n&quot;);
                } elseif ($patchType === 'remove') {
                    $posDelta -= strlen($patchText);
                    $lineDelta -= substr_count($patchText, &quot;\n&quot;);
                }
            }

            $attrs['startFilePos'] += $posDelta;
            $attrs['endFilePos'] += $posDelta;
            $attrs['startLine'] += $lineDelta;
            $attrs['endLine'] += $lineDelta;
            $error-&gt;setAttributes($attrs);
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>