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

namespace PhpParser;

/*
 * This parser is based on a skeleton written by Moriyoshi Koizumi, which in
 * turn is based on work by Masato Bito.
 */

use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\Cast\Double;
use PhpParser\Node\Identifier;
use PhpParser\Node\InterpolatedStringPart;
use PhpParser\Node\Name;
use PhpParser\Node\Param;
use PhpParser\Node\Scalar\InterpolatedString;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassConst;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Else_;
use PhpParser\Node\Stmt\ElseIf_;
use PhpParser\Node\Stmt\Enum_;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Namespace_;
use PhpParser\Node\Stmt\Nop;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\TryCatch;
use PhpParser\Node\UseItem;
use PhpParser\NodeVisitor\CommentAnnotatingVisitor;

abstract class ParserAbstract implements Parser {
    private const SYMBOL_NONE = -1;

    /** @var Lexer Lexer that is used when parsing */
    protected Lexer $lexer;
    /** @var PhpVersion PHP version to target on a best-effort basis */
    protected PhpVersion $phpVersion;

    /*
     * The following members will be filled with generated parsing data:
     */

    /** @var int Size of $tokenToSymbol map */
    protected int $tokenToSymbolMapSize;
    /** @var int Size of $action table */
    protected int $actionTableSize;
    /** @var int Size of $goto table */
    protected int $gotoTableSize;

    /** @var int Symbol number signifying an invalid token */
    protected int $invalidSymbol;
    /** @var int Symbol number of error recovery token */
    protected int $errorSymbol;
    /** @var int Action number signifying default action */
    protected int $defaultAction;
    /** @var int Rule number signifying that an unexpected token was encountered */
    protected int $unexpectedTokenRule;

    protected int $YY2TBLSTATE;
    /** @var int Number of non-leaf states */
    protected int $numNonLeafStates;

    /** @var int[] Map of PHP token IDs to internal symbols */
    protected array $phpTokenToSymbol;
    /** @var array&lt;int, bool&gt; Map of PHP token IDs to drop */
    protected array $dropTokens;
    /** @var int[] Map of external symbols (static::T_*) to internal symbols */
    protected array $tokenToSymbol;
    /** @var string[] Map of symbols to their names */
    protected array $symbolToName;
    /** @var array&lt;int, string&gt; Names of the production rules (only necessary for debugging) */
    protected array $productions;

    /** @var int[] Map of states to a displacement into the $action table. The corresponding action for this
     *             state/symbol pair is $action[$actionBase[$state] + $symbol]. If $actionBase[$state] is 0, the
     *             action is defaulted, i.e. $actionDefault[$state] should be used instead. */
    protected array $actionBase;
    /** @var int[] Table of actions. Indexed according to $actionBase comment. */
    protected array $action;
    /** @var int[] Table indexed analogously to $action. If $actionCheck[$actionBase[$state] + $symbol] != $symbol
     *             then the action is defaulted, i.e. $actionDefault[$state] should be used instead. */
    protected array $actionCheck;
    /** @var int[] Map of states to their default action */
    protected array $actionDefault;
    /** @var callable[] Semantic action callbacks */
    protected array $reduceCallbacks;

    /** @var int[] Map of non-terminals to a displacement into the $goto table. The corresponding goto state for this
     *             non-terminal/state pair is $goto[$gotoBase[$nonTerminal] + $state] (unless defaulted) */
    protected array $gotoBase;
    /** @var int[] Table of states to goto after reduction. Indexed according to $gotoBase comment. */
    protected array $goto;
    /** @var int[] Table indexed analogously to $goto. If $gotoCheck[$gotoBase[$nonTerminal] + $state] != $nonTerminal
     *             then the goto state is defaulted, i.e. $gotoDefault[$nonTerminal] should be used. */
    protected array $gotoCheck;
    /** @var int[] Map of non-terminals to the default state to goto after their reduction */
    protected array $gotoDefault;

    /** @var int[] Map of rules to the non-terminal on their left-hand side, i.e. the non-terminal to use for
     *             determining the state to goto after reduction. */
    protected array $ruleToNonTerminal;
    /** @var int[] Map of rules to the length of their right-hand side, which is the number of elements that have to
     *             be popped from the stack(s) on reduction. */
    protected array $ruleToLength;

    /*
     * The following members are part of the parser state:
     */

    /** @var mixed Temporary value containing the result of last semantic action (reduction) */
    protected $semValue;
    /** @var mixed[] Semantic value stack (contains values of tokens and semantic action results) */
    protected array $semStack;
    /** @var int[] Token start position stack */
    protected array $tokenStartStack;
    /** @var int[] Token end position stack */
    protected array $tokenEndStack;

    /** @var ErrorHandler Error handler */
    protected ErrorHandler $errorHandler;
    /** @var int Error state, used to avoid error floods */
    protected int $errorState;

    /** @var \SplObjectStorage&lt;Array_, null&gt;|null Array nodes created during parsing, for postprocessing of empty elements. */
    protected ?\SplObjectStorage $createdArrays;

    /** @var Token[] Tokens for the current parse */
    protected array $tokens;
    /** @var int Current position in token array */
    protected int $tokenPos;

    /**
     * Initialize $reduceCallbacks map.
     */
    abstract protected function initReduceCallbacks(): void;

    /**
     * Creates a parser instance.
     *
     * Options:
     *  * phpVersion: ?PhpVersion,
     *
     * @param Lexer $lexer A lexer
     * @param PhpVersion $phpVersion PHP version to target, defaults to latest supported. This
     *                               option is best-effort: Even if specified, parsing will generally assume the latest
     *                               supported version and only adjust behavior in minor ways, for example by omitting
     *                               errors in older versions and interpreting type hints as a name or identifier depending
     *                               on version.
     */
    public function __construct(Lexer $lexer, ?PhpVersion $phpVersion = null) {
        $this-&gt;lexer = $lexer;
        $this-&gt;phpVersion = $phpVersion ?? PhpVersion::getNewestSupported();

        $this-&gt;initReduceCallbacks();
        $this-&gt;phpTokenToSymbol = $this-&gt;createTokenMap();
        $this-&gt;dropTokens = array_fill_keys(
            [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], true
        );
    }

    /**
     * Parses PHP code into a node tree.
     *
     * If a non-throwing error handler is used, the parser will continue parsing after an error
     * occurred and attempt to build a partial AST.
     *
     * @param string $code The source code to parse
     * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
     *                                        to ErrorHandler\Throwing.
     *
     * @return Node\Stmt[]|null Array of statements (or null non-throwing error handler is used and
     *                          the parser was unable to recover from an error).
     */
    public function parse(string $code, ?ErrorHandler $errorHandler = null): ?array {
        $this-&gt;errorHandler = $errorHandler ?: new ErrorHandler\Throwing();
        $this-&gt;createdArrays = new \SplObjectStorage();

        $this-&gt;tokens = $this-&gt;lexer-&gt;tokenize($code, $this-&gt;errorHandler);
        $result = $this-&gt;doParse();

        // Report errors for any empty elements used inside arrays. This is delayed until after the main parse,
        // because we don't know a priori whether a given array expression will be used in a destructuring context
        // or not.
        foreach ($this-&gt;createdArrays as $node) {
            foreach ($node-&gt;items as $item) {
                if ($item-&gt;value instanceof Expr\Error) {
                    $this-&gt;errorHandler-&gt;handleError(
                        new Error('Cannot use empty array elements in arrays', $item-&gt;getAttributes()));
                }
            }
        }

        // Clear out some of the interior state, so we don't hold onto unnecessary
        // memory between uses of the parser
        $this-&gt;tokenStartStack = [];
        $this-&gt;tokenEndStack = [];
        $this-&gt;semStack = [];
        $this-&gt;semValue = null;
        $this-&gt;createdArrays = null;

        if ($result !== null) {
            $traverser = new NodeTraverser(new CommentAnnotatingVisitor($this-&gt;tokens));
            $traverser-&gt;traverse($result);
        }

        return $result;
    }

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

    /** @return Stmt[]|null */
    protected function doParse(): ?array {
        // We start off with no lookahead-token
        $symbol = self::SYMBOL_NONE;
        $tokenValue = null;
        $this-&gt;tokenPos = -1;

        // Keep stack of start and end attributes
        $this-&gt;tokenStartStack = [];
        $this-&gt;tokenEndStack = [0];

        // Start off in the initial state and keep a stack of previous states
        $state = 0;
        $stateStack = [$state];

        // Semantic value stack (contains values of tokens and semantic action results)
        $this-&gt;semStack = [];

        // Current position in the stack(s)
        $stackPos = 0;

        $this-&gt;errorState = 0;

        for (;;) {
            //$this-&gt;traceNewState($state, $symbol);

            if ($this-&gt;actionBase[$state] === 0) {
                $rule = $this-&gt;actionDefault[$state];
            } else {
                if ($symbol === self::SYMBOL_NONE) {
                    do {
                        $token = $this-&gt;tokens[++$this-&gt;tokenPos];
                        $tokenId = $token-&gt;id;
                    } while (isset($this-&gt;dropTokens[$tokenId]));

                    // Map the lexer token id to the internally used symbols.
                    $tokenValue = $token-&gt;text;
                    if (!isset($this-&gt;phpTokenToSymbol[$tokenId])) {
                        throw new \RangeException(sprintf(
                            'The lexer returned an invalid token (id=%d, value=%s)',
                            $tokenId, $tokenValue
                        ));
                    }
                    $symbol = $this-&gt;phpTokenToSymbol[$tokenId];

                    //$this-&gt;traceRead($symbol);
                }

                $idx = $this-&gt;actionBase[$state] + $symbol;
                if ((($idx &gt;= 0 &amp;&amp; $idx &lt; $this-&gt;actionTableSize &amp;&amp; $this-&gt;actionCheck[$idx] === $symbol)
                     || ($state &lt; $this-&gt;YY2TBLSTATE
                         &amp;&amp; ($idx = $this-&gt;actionBase[$state + $this-&gt;numNonLeafStates] + $symbol) &gt;= 0
                         &amp;&amp; $idx &lt; $this-&gt;actionTableSize &amp;&amp; $this-&gt;actionCheck[$idx] === $symbol))
                    &amp;&amp; ($action = $this-&gt;action[$idx]) !== $this-&gt;defaultAction) {
                    /*
                     * &gt;= numNonLeafStates: shift and reduce
                     * &gt; 0: shift
                     * = 0: accept
                     * &lt; 0: reduce
                     * = -YYUNEXPECTED: error
                     */
                    if ($action &gt; 0) {
                        /* shift */
                        //$this-&gt;traceShift($symbol);

                        ++$stackPos;
                        $stateStack[$stackPos] = $state = $action;
                        $this-&gt;semStack[$stackPos] = $tokenValue;
                        $this-&gt;tokenStartStack[$stackPos] = $this-&gt;tokenPos;
                        $this-&gt;tokenEndStack[$stackPos] = $this-&gt;tokenPos;
                        $symbol = self::SYMBOL_NONE;

                        if ($this-&gt;errorState) {
                            --$this-&gt;errorState;
                        }

                        if ($action &lt; $this-&gt;numNonLeafStates) {
                            continue;
                        }

                        /* $yyn &gt;= numNonLeafStates means shift-and-reduce */
                        $rule = $action - $this-&gt;numNonLeafStates;
                    } else {
                        $rule = -$action;
                    }
                } else {
                    $rule = $this-&gt;actionDefault[$state];
                }
            }

            for (;;) {
                if ($rule === 0) {
                    /* accept */
                    //$this-&gt;traceAccept();
                    return $this-&gt;semValue;
                }
                if ($rule !== $this-&gt;unexpectedTokenRule) {
                    /* reduce */
                    //$this-&gt;traceReduce($rule);

                    $ruleLength = $this-&gt;ruleToLength[$rule];
                    try {
                        $callback = $this-&gt;reduceCallbacks[$rule];
                        if ($callback !== null) {
                            $callback($this, $stackPos);
                        } elseif ($ruleLength &gt; 0) {
                            $this-&gt;semValue = $this-&gt;semStack[$stackPos - $ruleLength + 1];
                        }
                    } catch (Error $e) {
                        if (-1 === $e-&gt;getStartLine()) {
                            $e-&gt;setStartLine($this-&gt;tokens[$this-&gt;tokenPos]-&gt;line);
                        }

                        $this-&gt;emitError($e);
                        // Can't recover from this type of error
                        return null;
                    }

                    /* Goto - shift nonterminal */
                    $lastTokenEnd = $this-&gt;tokenEndStack[$stackPos];
                    $stackPos -= $ruleLength;
                    $nonTerminal = $this-&gt;ruleToNonTerminal[$rule];
                    $idx = $this-&gt;gotoBase[$nonTerminal] + $stateStack[$stackPos];
                    if ($idx &gt;= 0 &amp;&amp; $idx &lt; $this-&gt;gotoTableSize &amp;&amp; $this-&gt;gotoCheck[$idx] === $nonTerminal) {
                        $state = $this-&gt;goto[$idx];
                    } else {
                        $state = $this-&gt;gotoDefault[$nonTerminal];
                    }

                    ++$stackPos;
                    $stateStack[$stackPos]     = $state;
                    $this-&gt;semStack[$stackPos] = $this-&gt;semValue;
                    $this-&gt;tokenEndStack[$stackPos] = $lastTokenEnd;
                    if ($ruleLength === 0) {
                        // Empty productions use the start attributes of the lookahead token.
                        $this-&gt;tokenStartStack[$stackPos] = $this-&gt;tokenPos;
                    }
                } else {
                    /* error */
                    switch ($this-&gt;errorState) {
                        case 0:
                            $msg = $this-&gt;getErrorMessage($symbol, $state);
                            $this-&gt;emitError(new Error($msg, $this-&gt;getAttributesForToken($this-&gt;tokenPos)));
                            // Break missing intentionally
                            // no break
                        case 1:
                        case 2:
                            $this-&gt;errorState = 3;

                            // Pop until error-expecting state uncovered
                            while (!(
                                (($idx = $this-&gt;actionBase[$state] + $this-&gt;errorSymbol) &gt;= 0
                                    &amp;&amp; $idx &lt; $this-&gt;actionTableSize &amp;&amp; $this-&gt;actionCheck[$idx] === $this-&gt;errorSymbol)
                                || ($state &lt; $this-&gt;YY2TBLSTATE
                                    &amp;&amp; ($idx = $this-&gt;actionBase[$state + $this-&gt;numNonLeafStates] + $this-&gt;errorSymbol) &gt;= 0
                                    &amp;&amp; $idx &lt; $this-&gt;actionTableSize &amp;&amp; $this-&gt;actionCheck[$idx] === $this-&gt;errorSymbol)
                            ) || ($action = $this-&gt;action[$idx]) === $this-&gt;defaultAction) { // Not totally sure about this
                                if ($stackPos &lt;= 0) {
                                    // Could not recover from error
                                    return null;
                                }
                                $state = $stateStack[--$stackPos];
                                //$this-&gt;tracePop($state);
                            }

                            //$this-&gt;traceShift($this-&gt;errorSymbol);
                            ++$stackPos;
                            $stateStack[$stackPos] = $state = $action;

                            // We treat the error symbol as being empty, so we reset the end attributes
                            // to the end attributes of the last non-error symbol
                            $this-&gt;tokenStartStack[$stackPos] = $this-&gt;tokenPos;
                            $this-&gt;tokenEndStack[$stackPos] = $this-&gt;tokenEndStack[$stackPos - 1];
                            break;

                        case 3:
                            if ($symbol === 0) {
                                // Reached EOF without recovering from error
                                return null;
                            }

                            //$this-&gt;traceDiscard($symbol);
                            $symbol = self::SYMBOL_NONE;
                            break 2;
                    }
                }

                if ($state &lt; $this-&gt;numNonLeafStates) {
                    break;
                }

                /* &gt;= numNonLeafStates means shift-and-reduce */
                $rule = $state - $this-&gt;numNonLeafStates;
            }
        }

        throw new \RuntimeException('Reached end of parser loop');
    }

    protected function emitError(Error $error): void {
        $this-&gt;errorHandler-&gt;handleError($error);
    }

    /**
     * Format error message including expected tokens.
     *
     * @param int $symbol Unexpected symbol
     * @param int $state State at time of error
     *
     * @return string Formatted error message
     */
    protected function getErrorMessage(int $symbol, int $state): string {
        $expectedString = '';
        if ($expected = $this-&gt;getExpectedTokens($state)) {
            $expectedString = ', expecting ' . implode(' or ', $expected);
        }

        return 'Syntax error, unexpected ' . $this-&gt;symbolToName[$symbol] . $expectedString;
    }

    /**
     * Get limited number of expected tokens in given state.
     *
     * @param int $state State
     *
     * @return string[] Expected tokens. If too many, an empty array is returned.
     */
    protected function getExpectedTokens(int $state): array {
        $expected = [];

        $base = $this-&gt;actionBase[$state];
        foreach ($this-&gt;symbolToName as $symbol =&gt; $name) {
            $idx = $base + $symbol;
            if ($idx &gt;= 0 &amp;&amp; $idx &lt; $this-&gt;actionTableSize &amp;&amp; $this-&gt;actionCheck[$idx] === $symbol
                || $state &lt; $this-&gt;YY2TBLSTATE
                &amp;&amp; ($idx = $this-&gt;actionBase[$state + $this-&gt;numNonLeafStates] + $symbol) &gt;= 0
                &amp;&amp; $idx &lt; $this-&gt;actionTableSize &amp;&amp; $this-&gt;actionCheck[$idx] === $symbol
            ) {
                if ($this-&gt;action[$idx] !== $this-&gt;unexpectedTokenRule
                    &amp;&amp; $this-&gt;action[$idx] !== $this-&gt;defaultAction
                    &amp;&amp; $symbol !== $this-&gt;errorSymbol
                ) {
                    if (count($expected) === 4) {
                        /* Too many expected tokens */
                        return [];
                    }

                    $expected[] = $name;
                }
            }
        }

        return $expected;
    }

    /**
     * Get attributes for a node with the given start and end token positions.
     *
     * @param int $tokenStartPos Token position the node starts at
     * @param int $tokenEndPos Token position the node ends at
     * @return array&lt;string, mixed&gt; Attributes
     */
    protected function getAttributes(int $tokenStartPos, int $tokenEndPos): array {
        $startToken = $this-&gt;tokens[$tokenStartPos];
        $afterEndToken = $this-&gt;tokens[$tokenEndPos + 1];
        return [
            'startLine' =&gt; $startToken-&gt;line,
            'startTokenPos' =&gt; $tokenStartPos,
            'startFilePos' =&gt; $startToken-&gt;pos,
            'endLine' =&gt; $afterEndToken-&gt;line,
            'endTokenPos' =&gt; $tokenEndPos,
            'endFilePos' =&gt; $afterEndToken-&gt;pos - 1,
        ];
    }

    /**
     * Get attributes for a single token at the given token position.
     *
     * @return array&lt;string, mixed&gt; Attributes
     */
    protected function getAttributesForToken(int $tokenPos): array {
        if ($tokenPos &lt; \count($this-&gt;tokens) - 1) {
            return $this-&gt;getAttributes($tokenPos, $tokenPos);
        }

        // Get attributes for the sentinel token.
        $token = $this-&gt;tokens[$tokenPos];
        return [
            'startLine' =&gt; $token-&gt;line,
            'startTokenPos' =&gt; $tokenPos,
            'startFilePos' =&gt; $token-&gt;pos,
            'endLine' =&gt; $token-&gt;line,
            'endTokenPos' =&gt; $tokenPos,
            'endFilePos' =&gt; $token-&gt;pos,
        ];
    }

    /*
     * Tracing functions used for debugging the parser.
     */

    /*
    protected function traceNewState($state, $symbol): void {
        echo '% State ' . $state
            . ', Lookahead ' . ($symbol == self::SYMBOL_NONE ? '--none--' : $this-&gt;symbolToName[$symbol]) . &quot;\n&quot;;
    }

    protected function traceRead($symbol): void {
        echo '% Reading ' . $this-&gt;symbolToName[$symbol] . &quot;\n&quot;;
    }

    protected function traceShift($symbol): void {
        echo '% Shift ' . $this-&gt;symbolToName[$symbol] . &quot;\n&quot;;
    }

    protected function traceAccept(): void {
        echo &quot;% Accepted.\n&quot;;
    }

    protected function traceReduce($n): void {
        echo '% Reduce by (' . $n . ') ' . $this-&gt;productions[$n] . &quot;\n&quot;;
    }

    protected function tracePop($state): void {
        echo '% Recovering, uncovered state ' . $state . &quot;\n&quot;;
    }

    protected function traceDiscard($symbol): void {
        echo '% Discard ' . $this-&gt;symbolToName[$symbol] . &quot;\n&quot;;
    }
    */

    /*
     * Helper functions invoked by semantic actions
     */

    /**
     * Moves statements of semicolon-style namespaces into $ns-&gt;stmts and checks various error conditions.
     *
     * @param Node\Stmt[] $stmts
     * @return Node\Stmt[]
     */
    protected function handleNamespaces(array $stmts): array {
        $hasErrored = false;
        $style = $this-&gt;getNamespacingStyle($stmts);
        if (null === $style) {
            // not namespaced, nothing to do
            return $stmts;
        }
        if ('brace' === $style) {
            // For braced namespaces we only have to check that there are no invalid statements between the namespaces
            $afterFirstNamespace = false;
            foreach ($stmts as $stmt) {
                if ($stmt instanceof Node\Stmt\Namespace_) {
                    $afterFirstNamespace = true;
                } elseif (!$stmt instanceof Node\Stmt\HaltCompiler
                        &amp;&amp; !$stmt instanceof Node\Stmt\Nop
                        &amp;&amp; $afterFirstNamespace &amp;&amp; !$hasErrored) {
                    $this-&gt;emitError(new Error(
                        'No code may exist outside of namespace {}', $stmt-&gt;getAttributes()));
                    $hasErrored = true; // Avoid one error for every statement
                }
            }
            return $stmts;
        } else {
            // For semicolon namespaces we have to move the statements after a namespace declaration into -&gt;stmts
            $resultStmts = [];
            $targetStmts = &amp;$resultStmts;
            $lastNs = null;
            foreach ($stmts as $stmt) {
                if ($stmt instanceof Node\Stmt\Namespace_) {
                    if ($lastNs !== null) {
                        $this-&gt;fixupNamespaceAttributes($lastNs);
                    }
                    if ($stmt-&gt;stmts === null) {
                        $stmt-&gt;stmts = [];
                        $targetStmts = &amp;$stmt-&gt;stmts;
                        $resultStmts[] = $stmt;
                    } else {
                        // This handles the invalid case of mixed style namespaces
                        $resultStmts[] = $stmt;
                        $targetStmts = &amp;$resultStmts;
                    }
                    $lastNs = $stmt;
                } elseif ($stmt instanceof Node\Stmt\HaltCompiler) {
                    // __halt_compiler() is not moved into the namespace
                    $resultStmts[] = $stmt;
                } else {
                    $targetStmts[] = $stmt;
                }
            }
            if ($lastNs !== null) {
                $this-&gt;fixupNamespaceAttributes($lastNs);
            }
            return $resultStmts;
        }
    }

    private function fixupNamespaceAttributes(Node\Stmt\Namespace_ $stmt): void {
        // We moved the statements into the namespace node, as such the end of the namespace node
        // needs to be extended to the end of the statements.
        if (empty($stmt-&gt;stmts)) {
            return;
        }

        // We only move the builtin end attributes here. This is the best we can do with the
        // knowledge we have.
        $endAttributes = ['endLine', 'endFilePos', 'endTokenPos'];
        $lastStmt = $stmt-&gt;stmts[count($stmt-&gt;stmts) - 1];
        foreach ($endAttributes as $endAttribute) {
            if ($lastStmt-&gt;hasAttribute($endAttribute)) {
                $stmt-&gt;setAttribute($endAttribute, $lastStmt-&gt;getAttribute($endAttribute));
            }
        }
    }

    /** @return array&lt;string, mixed&gt; */
    private function getNamespaceErrorAttributes(Namespace_ $node): array {
        $attrs = $node-&gt;getAttributes();
        // Adjust end attributes to only cover the &quot;namespace&quot; keyword, not the whole namespace.
        if (isset($attrs['startLine'])) {
            $attrs['endLine'] = $attrs['startLine'];
        }
        if (isset($attrs['startTokenPos'])) {
            $attrs['endTokenPos'] = $attrs['startTokenPos'];
        }
        if (isset($attrs['startFilePos'])) {
            $attrs['endFilePos'] = $attrs['startFilePos'] + \strlen('namespace') - 1;
        }
        return $attrs;
    }

    /**
     * Determine namespacing style (semicolon or brace)
     *
     * @param Node[] $stmts Top-level statements.
     *
     * @return null|string One of &quot;semicolon&quot;, &quot;brace&quot; or null (no namespaces)
     */
    private function getNamespacingStyle(array $stmts): ?string {
        $style = null;
        $hasNotAllowedStmts = false;
        foreach ($stmts as $i =&gt; $stmt) {
            if ($stmt instanceof Node\Stmt\Namespace_) {
                $currentStyle = null === $stmt-&gt;stmts ? 'semicolon' : 'brace';
                if (null === $style) {
                    $style = $currentStyle;
                    if ($hasNotAllowedStmts) {
                        $this-&gt;emitError(new Error(
                            'Namespace declaration statement has to be the very first statement in the script',
                            $this-&gt;getNamespaceErrorAttributes($stmt)
                        ));
                    }
                } elseif ($style !== $currentStyle) {
                    $this-&gt;emitError(new Error(
                        'Cannot mix bracketed namespace declarations with unbracketed namespace declarations',
                        $this-&gt;getNamespaceErrorAttributes($stmt)
                    ));
                    // Treat like semicolon style for namespace normalization
                    return 'semicolon';
                }
                continue;
            }

            /* declare(), __halt_compiler() and nops can be used before a namespace declaration */
            if ($stmt instanceof Node\Stmt\Declare_
                || $stmt instanceof Node\Stmt\HaltCompiler
                || $stmt instanceof Node\Stmt\Nop) {
                continue;
            }

            /* There may be a hashbang line at the very start of the file */
            if ($i === 0 &amp;&amp; $stmt instanceof Node\Stmt\InlineHTML &amp;&amp; preg_match('/\A#!.*\r?\n\z/', $stmt-&gt;value)) {
                continue;
            }

            /* Everything else if forbidden before namespace declarations */
            $hasNotAllowedStmts = true;
        }
        return $style;
    }

    /** @return Name|Identifier */
    protected function handleBuiltinTypes(Name $name) {
        if (!$name-&gt;isUnqualified()) {
            return $name;
        }

        $lowerName = $name-&gt;toLowerString();
        if (!$this-&gt;phpVersion-&gt;supportsBuiltinType($lowerName)) {
            return $name;
        }

        return new Node\Identifier($lowerName, $name-&gt;getAttributes());
    }

    /**
     * Get combined start and end attributes at a stack location
     *
     * @param int $stackPos Stack location
     *
     * @return array&lt;string, mixed&gt; Combined start and end attributes
     */
    protected function getAttributesAt(int $stackPos): array {
        return $this-&gt;getAttributes($this-&gt;tokenStartStack[$stackPos], $this-&gt;tokenEndStack[$stackPos]);
    }

    protected function getFloatCastKind(string $cast): int {
        $cast = strtolower($cast);
        if (strpos($cast, 'float') !== false) {
            return Double::KIND_FLOAT;
        }

        if (strpos($cast, 'real') !== false) {
            return Double::KIND_REAL;
        }

        return Double::KIND_DOUBLE;
    }

    /** @param array&lt;string, mixed&gt; $attributes */
    protected function parseLNumber(string $str, array $attributes, bool $allowInvalidOctal = false): Int_ {
        try {
            return Int_::fromString($str, $attributes, $allowInvalidOctal);
        } catch (Error $error) {
            $this-&gt;emitError($error);
            // Use dummy value
            return new Int_(0, $attributes);
        }
    }

    /**
     * Parse a T_NUM_STRING token into either an integer or string node.
     *
     * @param string $str Number string
     * @param array&lt;string, mixed&gt; $attributes Attributes
     *
     * @return Int_|String_ Integer or string node.
     */
    protected function parseNumString(string $str, array $attributes) {
        if (!preg_match('/^(?:0|-?[1-9][0-9]*)$/', $str)) {
            return new String_($str, $attributes);
        }

        $num = +$str;
        if (!is_int($num)) {
            return new String_($str, $attributes);
        }

        return new Int_($num, $attributes);
    }

    /** @param array&lt;string, mixed&gt; $attributes */
    protected function stripIndentation(
        string $string, int $indentLen, string $indentChar,
        bool $newlineAtStart, bool $newlineAtEnd, array $attributes
    ): string {
        if ($indentLen === 0) {
            return $string;
        }

        $start = $newlineAtStart ? '(?:(?&lt;=\n)|\A)' : '(?&lt;=\n)';
        $end = $newlineAtEnd ? '(?:(?=[\r\n])|\z)' : '(?=[\r\n])';
        $regex = '/' . $start . '([ \t]*)(' . $end . ')?/';
        return preg_replace_callback(
            $regex,
            function ($matches) use ($indentLen, $indentChar, $attributes) {
                $prefix = substr($matches[1], 0, $indentLen);
                if (false !== strpos($prefix, $indentChar === &quot; &quot; ? &quot;\t&quot; : &quot; &quot;)) {
                    $this-&gt;emitError(new Error(
                        'Invalid indentation - tabs and spaces cannot be mixed', $attributes
                    ));
                } elseif (strlen($prefix) &lt; $indentLen &amp;&amp; !isset($matches[2])) {
                    $this-&gt;emitError(new Error(
                        'Invalid body indentation level ' .
                        '(expecting an indentation level of at least ' . $indentLen . ')',
                        $attributes
                    ));
                }
                return substr($matches[0], strlen($prefix));
            },
            $string
        );
    }

    /**
     * @param string|(Expr|InterpolatedStringPart)[] $contents
     * @param array&lt;string, mixed&gt; $attributes
     * @param array&lt;string, mixed&gt; $endTokenAttributes
     */
    protected function parseDocString(
        string $startToken, $contents, string $endToken,
        array $attributes, array $endTokenAttributes, bool $parseUnicodeEscape
    ): Expr {
        $kind = strpos($startToken, &quot;'&quot;) === false
            ? String_::KIND_HEREDOC : String_::KIND_NOWDOC;

        $regex = '/\A[bB]?&lt;&lt;&lt;[ \t]*[\'&quot;]?([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)[\'&quot;]?(?:\r\n|\n|\r)\z/';
        $result = preg_match($regex, $startToken, $matches);
        assert($result === 1);
        $label = $matches[1];

        $result = preg_match('/\A[ \t]*/', $endToken, $matches);
        assert($result === 1);
        $indentation = $matches[0];

        $attributes['kind'] = $kind;
        $attributes['docLabel'] = $label;
        $attributes['docIndentation'] = $indentation;

        $indentHasSpaces = false !== strpos($indentation, &quot; &quot;);
        $indentHasTabs = false !== strpos($indentation, &quot;\t&quot;);
        if ($indentHasSpaces &amp;&amp; $indentHasTabs) {
            $this-&gt;emitError(new Error(
                'Invalid indentation - tabs and spaces cannot be mixed',
                $endTokenAttributes
            ));

            // Proceed processing as if this doc string is not indented
            $indentation = '';
        }

        $indentLen = \strlen($indentation);
        $indentChar = $indentHasSpaces ? &quot; &quot; : &quot;\t&quot;;

        if (\is_string($contents)) {
            if ($contents === '') {
                $attributes['rawValue'] = $contents;
                return new String_('', $attributes);
            }

            $contents = $this-&gt;stripIndentation(
                $contents, $indentLen, $indentChar, true, true, $attributes
            );
            $contents = preg_replace('~(\r\n|\n|\r)\z~', '', $contents);
            $attributes['rawValue'] = $contents;

            if ($kind === String_::KIND_HEREDOC) {
                $contents = String_::parseEscapeSequences($contents, null, $parseUnicodeEscape);
            }

            return new String_($contents, $attributes);
        } else {
            assert(count($contents) &gt; 0);
            if (!$contents[0] instanceof Node\InterpolatedStringPart) {
                // If there is no leading encapsed string part, pretend there is an empty one
                $this-&gt;stripIndentation(
                    '', $indentLen, $indentChar, true, false, $contents[0]-&gt;getAttributes()
                );
            }

            $newContents = [];
            foreach ($contents as $i =&gt; $part) {
                if ($part instanceof Node\InterpolatedStringPart) {
                    $isLast = $i === \count($contents) - 1;
                    $part-&gt;value = $this-&gt;stripIndentation(
                        $part-&gt;value, $indentLen, $indentChar,
                        $i === 0, $isLast, $part-&gt;getAttributes()
                    );
                    if ($isLast) {
                        $part-&gt;value = preg_replace('~(\r\n|\n|\r)\z~', '', $part-&gt;value);
                    }
                    $part-&gt;setAttribute('rawValue', $part-&gt;value);
                    $part-&gt;value = String_::parseEscapeSequences($part-&gt;value, null, $parseUnicodeEscape);
                    if ('' === $part-&gt;value) {
                        continue;
                    }
                }
                $newContents[] = $part;
            }
            return new InterpolatedString($newContents, $attributes);
        }
    }

    protected function createCommentFromToken(Token $token, int $tokenPos): Comment {
        assert($token-&gt;id === \T_COMMENT || $token-&gt;id == \T_DOC_COMMENT);
        return \T_DOC_COMMENT === $token-&gt;id
            ? new Comment\Doc($token-&gt;text, $token-&gt;line, $token-&gt;pos, $tokenPos,
                $token-&gt;getEndLine(), $token-&gt;getEndPos() - 1, $tokenPos)
            : new Comment($token-&gt;text, $token-&gt;line, $token-&gt;pos, $tokenPos,
                $token-&gt;getEndLine(), $token-&gt;getEndPos() - 1, $tokenPos);
    }

    /**
     * Get last comment before the given token position, if any
     */
    protected function getCommentBeforeToken(int $tokenPos): ?Comment {
        while (--$tokenPos &gt;= 0) {
            $token = $this-&gt;tokens[$tokenPos];
            if (!isset($this-&gt;dropTokens[$token-&gt;id])) {
                break;
            }

            if ($token-&gt;id === \T_COMMENT || $token-&gt;id === \T_DOC_COMMENT) {
                return $this-&gt;createCommentFromToken($token, $tokenPos);
            }
        }
        return null;
    }

    /**
     * Create a zero-length nop to capture preceding comments, if any.
     */
    protected function maybeCreateZeroLengthNop(int $tokenPos): ?Nop {
        $comment = $this-&gt;getCommentBeforeToken($tokenPos);
        if ($comment === null) {
            return null;
        }

        $commentEndLine = $comment-&gt;getEndLine();
        $commentEndFilePos = $comment-&gt;getEndFilePos();
        $commentEndTokenPos = $comment-&gt;getEndTokenPos();
        $attributes = [
            'startLine' =&gt; $commentEndLine,
            'endLine' =&gt; $commentEndLine,
            'startFilePos' =&gt; $commentEndFilePos + 1,
            'endFilePos' =&gt; $commentEndFilePos,
            'startTokenPos' =&gt; $commentEndTokenPos + 1,
            'endTokenPos' =&gt; $commentEndTokenPos,
        ];
        return new Nop($attributes);
    }

    protected function maybeCreateNop(int $tokenStartPos, int $tokenEndPos): ?Nop {
        if ($this-&gt;getCommentBeforeToken($tokenStartPos) === null) {
            return null;
        }
        return new Nop($this-&gt;getAttributes($tokenStartPos, $tokenEndPos));
    }

    protected function handleHaltCompiler(): string {
        // Prevent the lexer from returning any further tokens.
        $nextToken = $this-&gt;tokens[$this-&gt;tokenPos + 1];
        $this-&gt;tokenPos = \count($this-&gt;tokens) - 2;

        // Return text after __halt_compiler.
        return $nextToken-&gt;id === \T_INLINE_HTML ? $nextToken-&gt;text : '';
    }

    protected function inlineHtmlHasLeadingNewline(int $stackPos): bool {
        $tokenPos = $this-&gt;tokenStartStack[$stackPos];
        $token = $this-&gt;tokens[$tokenPos];
        assert($token-&gt;id == \T_INLINE_HTML);
        if ($tokenPos &gt; 0) {
            $prevToken = $this-&gt;tokens[$tokenPos - 1];
            assert($prevToken-&gt;id == \T_CLOSE_TAG);
            return false !== strpos($prevToken-&gt;text, &quot;\n&quot;)
                || false !== strpos($prevToken-&gt;text, &quot;\r&quot;);
        }
        return true;
    }

    /**
     * @return array&lt;string, mixed&gt;
     */
    protected function createEmptyElemAttributes(int $tokenPos): array {
        return $this-&gt;getAttributesForToken($tokenPos);
    }

    protected function fixupArrayDestructuring(Array_ $node): Expr\List_ {
        $this-&gt;createdArrays-&gt;detach($node);
        return new Expr\List_(array_map(function (Node\ArrayItem $item) {
            if ($item-&gt;value instanceof Expr\Error) {
                // We used Error as a placeholder for empty elements, which are legal for destructuring.
                return null;
            }
            if ($item-&gt;value instanceof Array_) {
                return new Node\ArrayItem(
                    $this-&gt;fixupArrayDestructuring($item-&gt;value),
                    $item-&gt;key, $item-&gt;byRef, $item-&gt;getAttributes());
            }
            return $item;
        }, $node-&gt;items), ['kind' =&gt; Expr\List_::KIND_ARRAY] + $node-&gt;getAttributes());
    }

    protected function postprocessList(Expr\List_ $node): void {
        foreach ($node-&gt;items as $i =&gt; $item) {
            if ($item-&gt;value instanceof Expr\Error) {
                // We used Error as a placeholder for empty elements, which are legal for destructuring.
                $node-&gt;items[$i] = null;
            }
        }
    }

    /** @param ElseIf_|Else_ $node */
    protected function fixupAlternativeElse($node): void {
        // Make sure a trailing nop statement carrying comments is part of the node.
        $numStmts = \count($node-&gt;stmts);
        if ($numStmts !== 0 &amp;&amp; $node-&gt;stmts[$numStmts - 1] instanceof Nop) {
            $nopAttrs = $node-&gt;stmts[$numStmts - 1]-&gt;getAttributes();
            if (isset($nopAttrs['endLine'])) {
                $node-&gt;setAttribute('endLine', $nopAttrs['endLine']);
            }
            if (isset($nopAttrs['endFilePos'])) {
                $node-&gt;setAttribute('endFilePos', $nopAttrs['endFilePos']);
            }
            if (isset($nopAttrs['endTokenPos'])) {
                $node-&gt;setAttribute('endTokenPos', $nopAttrs['endTokenPos']);
            }
        }
    }

    protected function checkClassModifier(int $a, int $b, int $modifierPos): void {
        try {
            Modifiers::verifyClassModifier($a, $b);
        } catch (Error $error) {
            $error-&gt;setAttributes($this-&gt;getAttributesAt($modifierPos));
            $this-&gt;emitError($error);
        }
    }

    protected function checkModifier(int $a, int $b, int $modifierPos): void {
        // Jumping through some hoops here because verifyModifier() is also used elsewhere
        try {
            Modifiers::verifyModifier($a, $b);
        } catch (Error $error) {
            $error-&gt;setAttributes($this-&gt;getAttributesAt($modifierPos));
            $this-&gt;emitError($error);
        }
    }

    protected function checkParam(Param $node): void {
        if ($node-&gt;variadic &amp;&amp; null !== $node-&gt;default) {
            $this-&gt;emitError(new Error(
                'Variadic parameter cannot have a default value',
                $node-&gt;default-&gt;getAttributes()
            ));
        }
    }

    protected function checkTryCatch(TryCatch $node): void {
        if (empty($node-&gt;catches) &amp;&amp; null === $node-&gt;finally) {
            $this-&gt;emitError(new Error(
                'Cannot use try without catch or finally', $node-&gt;getAttributes()
            ));
        }
    }

    protected function checkNamespace(Namespace_ $node): void {
        if (null !== $node-&gt;stmts) {
            foreach ($node-&gt;stmts as $stmt) {
                if ($stmt instanceof Namespace_) {
                    $this-&gt;emitError(new Error(
                        'Namespace declarations cannot be nested', $stmt-&gt;getAttributes()
                    ));
                }
            }
        }
    }

    private function checkClassName(?Identifier $name, int $namePos): void {
        if (null !== $name &amp;&amp; $name-&gt;isSpecialClassName()) {
            $this-&gt;emitError(new Error(
                sprintf('Cannot use \'%s\' as class name as it is reserved', $name),
                $this-&gt;getAttributesAt($namePos)
            ));
        }
    }

    /** @param Name[] $interfaces */
    private function checkImplementedInterfaces(array $interfaces): void {
        foreach ($interfaces as $interface) {
            if ($interface-&gt;isSpecialClassName()) {
                $this-&gt;emitError(new Error(
                    sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
                    $interface-&gt;getAttributes()
                ));
            }
        }
    }

    protected function checkClass(Class_ $node, int $namePos): void {
        $this-&gt;checkClassName($node-&gt;name, $namePos);

        if ($node-&gt;extends &amp;&amp; $node-&gt;extends-&gt;isSpecialClassName()) {
            $this-&gt;emitError(new Error(
                sprintf('Cannot use \'%s\' as class name as it is reserved', $node-&gt;extends),
                $node-&gt;extends-&gt;getAttributes()
            ));
        }

        $this-&gt;checkImplementedInterfaces($node-&gt;implements);
    }

    protected function checkInterface(Interface_ $node, int $namePos): void {
        $this-&gt;checkClassName($node-&gt;name, $namePos);
        $this-&gt;checkImplementedInterfaces($node-&gt;extends);
    }

    protected function checkEnum(Enum_ $node, int $namePos): void {
        $this-&gt;checkClassName($node-&gt;name, $namePos);
        $this-&gt;checkImplementedInterfaces($node-&gt;implements);
    }

    protected function checkClassMethod(ClassMethod $node, int $modifierPos): void {
        if ($node-&gt;flags &amp; Modifiers::STATIC) {
            switch ($node-&gt;name-&gt;toLowerString()) {
                case '__construct':
                    $this-&gt;emitError(new Error(
                        sprintf('Constructor %s() cannot be static', $node-&gt;name),
                        $this-&gt;getAttributesAt($modifierPos)));
                    break;
                case '__destruct':
                    $this-&gt;emitError(new Error(
                        sprintf('Destructor %s() cannot be static', $node-&gt;name),
                        $this-&gt;getAttributesAt($modifierPos)));
                    break;
                case '__clone':
                    $this-&gt;emitError(new Error(
                        sprintf('Clone method %s() cannot be static', $node-&gt;name),
                        $this-&gt;getAttributesAt($modifierPos)));
                    break;
            }
        }

        if ($node-&gt;flags &amp; Modifiers::READONLY) {
            $this-&gt;emitError(new Error(
                sprintf('Method %s() cannot be readonly', $node-&gt;name),
                $this-&gt;getAttributesAt($modifierPos)));
        }
    }

    protected function checkClassConst(ClassConst $node, int $modifierPos): void {
        if ($node-&gt;flags &amp; Modifiers::STATIC) {
            $this-&gt;emitError(new Error(
                &quot;Cannot use 'static' as constant modifier&quot;,
                $this-&gt;getAttributesAt($modifierPos)));
        }
        if ($node-&gt;flags &amp; Modifiers::ABSTRACT) {
            $this-&gt;emitError(new Error(
                &quot;Cannot use 'abstract' as constant modifier&quot;,
                $this-&gt;getAttributesAt($modifierPos)));
        }
        if ($node-&gt;flags &amp; Modifiers::READONLY) {
            $this-&gt;emitError(new Error(
                &quot;Cannot use 'readonly' as constant modifier&quot;,
                $this-&gt;getAttributesAt($modifierPos)));
        }
    }

    protected function checkProperty(Property $node, int $modifierPos): void {
        if ($node-&gt;flags &amp; Modifiers::ABSTRACT) {
            $this-&gt;emitError(new Error('Properties cannot be declared abstract',
                $this-&gt;getAttributesAt($modifierPos)));
        }

        if ($node-&gt;flags &amp; Modifiers::FINAL) {
            $this-&gt;emitError(new Error('Properties cannot be declared final',
                $this-&gt;getAttributesAt($modifierPos)));
        }
    }

    protected function checkUseUse(UseItem $node, int $namePos): void {
        if ($node-&gt;alias &amp;&amp; $node-&gt;alias-&gt;isSpecialClassName()) {
            $this-&gt;emitError(new Error(
                sprintf(
                    'Cannot use %s as %s because \'%2$s\' is a special class name',
                    $node-&gt;name, $node-&gt;alias
                ),
                $this-&gt;getAttributesAt($namePos)
            ));
        }
    }

    /**
     * Creates the token map.
     *
     * The token map maps the PHP internal token identifiers
     * to the identifiers used by the Parser. Additionally it
     * maps T_OPEN_TAG_WITH_ECHO to T_ECHO and T_CLOSE_TAG to ';'.
     *
     * @return array&lt;int, int&gt; The token map
     */
    protected function createTokenMap(): array {
        $tokenMap = [];

        for ($i = 0; $i &lt; 1000; ++$i) {
            if ($i &lt; 256) {
                // Single-char tokens use an identity mapping.
                $tokenMap[$i] = $i;
            } elseif (\T_DOUBLE_COLON === $i) {
                // T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
                $tokenMap[$i] = static::T_PAAMAYIM_NEKUDOTAYIM;
            } elseif (\T_OPEN_TAG_WITH_ECHO === $i) {
                // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
                $tokenMap[$i] = static::T_ECHO;
            } elseif (\T_CLOSE_TAG === $i) {
                // T_CLOSE_TAG is equivalent to ';'
                $tokenMap[$i] = ord(';');
            } elseif ('UNKNOWN' !== $name = token_name($i)) {
                if (defined($name = static::class . '::' . $name)) {
                    // Other tokens can be mapped directly
                    $tokenMap[$i] = constant($name);
                }
            }
        }

        // Assign tokens for which we define compatibility constants, as token_name() does not know them.
        $tokenMap[\T_FN] = static::T_FN;
        $tokenMap[\T_COALESCE_EQUAL] = static::T_COALESCE_EQUAL;
        $tokenMap[\T_NAME_QUALIFIED] = static::T_NAME_QUALIFIED;
        $tokenMap[\T_NAME_FULLY_QUALIFIED] = static::T_NAME_FULLY_QUALIFIED;
        $tokenMap[\T_NAME_RELATIVE] = static::T_NAME_RELATIVE;
        $tokenMap[\T_MATCH] = static::T_MATCH;
        $tokenMap[\T_NULLSAFE_OBJECT_OPERATOR] = static::T_NULLSAFE_OBJECT_OPERATOR;
        $tokenMap[\T_ATTRIBUTE] = static::T_ATTRIBUTE;
        $tokenMap[\T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG] = static::T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG;
        $tokenMap[\T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG] = static::T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG;
        $tokenMap[\T_ENUM] = static::T_ENUM;
        $tokenMap[\T_READONLY] = static::T_READONLY;

        // We have create a map from PHP token IDs to external symbol IDs.
        // Now map them to the internal symbol ID.
        $fullTokenMap = [];
        foreach ($tokenMap as $phpToken =&gt; $extSymbol) {
            $intSymbol = $this-&gt;tokenToSymbol[$extSymbol];
            if ($intSymbol === $this-&gt;invalidSymbol) {
                continue;
            }
            $fullTokenMap[$phpToken] = $intSymbol;
        }

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