@flarum/cli 2.0.2 → 3.0.1

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php

@@ -6,137 +6,160 @@ 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\Encapsed;
-use PhpParser\Node\Scalar\LNumber;
+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\Stmt\UseUse;
-use PhpParser\Node\VarLikeIdentifier;
+use PhpParser\Node\UseItem;
+use PhpParser\NodeVisitor\CommentAnnotatingVisitor;
+
+abstract class ParserAbstract implements Parser {
+    private const SYMBOL_NONE = -1;
 
-abstract class ParserAbstract implements Parser
-{
-    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 $tokenToSymbolMapSize;
+    protected int $tokenToSymbolMapSize;
     /** @var int Size of $action table */
-    protected $actionTableSize;
+    protected int $actionTableSize;
     /** @var int Size of $goto table */
-    protected $gotoTableSize;
+    protected int $gotoTableSize;
 
     /** @var int Symbol number signifying an invalid token */
-    protected $invalidSymbol;
+    protected int $invalidSymbol;
     /** @var int Symbol number of error recovery token */
-    protected $errorSymbol;
+    protected int $errorSymbol;
     /** @var int Action number signifying default action */
-    protected $defaultAction;
+    protected int $defaultAction;
     /** @var int Rule number signifying that an unexpected token was encountered */
-    protected $unexpectedTokenRule;
+    protected int $unexpectedTokenRule;
 
-    protected $YY2TBLSTATE;
+    protected int $YY2TBLSTATE;
     /** @var int Number of non-leaf states */
-    protected $numNonLeafStates;
-
-    /** @var int[] Map of lexer tokens to internal symbols */
-    protected $tokenToSymbol;
+    protected int $numNonLeafStates;
+
+    /** @var int[] Map of PHP token IDs to internal symbols */
+    protected array $phpTokenToSymbol;
+    /** @var array<int, bool> 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 $symbolToName;
-    /** @var array Names of the production rules (only necessary for debugging) */
-    protected $productions;
+    protected array $symbolToName;
+    /** @var array<int, string> 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 $actionBase;
+    protected array $actionBase;
     /** @var int[] Table of actions. Indexed according to $actionBase comment. */
-    protected $action;
+    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 $actionCheck;
+    protected array $actionCheck;
     /** @var int[] Map of states to their default action */
-    protected $actionDefault;
+    protected array $actionDefault;
     /** @var callable[] Semantic action callbacks */
-    protected $reduceCallbacks;
+    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 $gotoBase;
+    protected array $gotoBase;
     /** @var int[] Table of states to goto after reduction. Indexed according to $gotoBase comment. */
-    protected $goto;
+    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 $gotoCheck;
+    protected array $gotoCheck;
     /** @var int[] Map of non-terminals to the default state to goto after their reduction */
-    protected $gotoDefault;
+    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 $ruleToNonTerminal;
+    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 $ruleToLength;
+    protected array $ruleToLength;
 
     /*
      * The following members are part of the parser state:
      */
 
-    /** @var Lexer Lexer that is used when parsing */
-    protected $lexer;
     /** @var mixed Temporary value containing the result of last semantic action (reduction) */
     protected $semValue;
-    /** @var array Semantic value stack (contains values of tokens and semantic action results) */
-    protected $semStack;
-    /** @var array[] Start attribute stack */
-    protected $startAttributeStack;
-    /** @var array[] End attribute stack */
-    protected $endAttributeStack;
-    /** @var array End attributes of last *shifted* token */
-    protected $endAttributes;
-    /** @var array Start attributes of last *read* token */
-    protected $lookaheadStartAttributes;
+    /** @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;
+    protected ErrorHandler $errorHandler;
     /** @var int Error state, used to avoid error floods */
-    protected $errorState;
+    protected int $errorState;
+
+    /** @var \SplObjectStorage<Array_, null>|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();
+    abstract protected function initReduceCallbacks(): void;
 
     /**
      * Creates a parser instance.
      *
-     * Options: Currently none.
+     * Options:
+     *  * phpVersion: ?PhpVersion,
      *
      * @param Lexer $lexer A lexer
-     * @param array $options Options array.
+     * @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, array $options = []) {
+    public function __construct(Lexer $lexer, ?PhpVersion $phpVersion = null) {
         $this->lexer = $lexer;
-
-        if (isset($options['throwOnError'])) {
-            throw new \LogicException(
-                '"throwOnError" is no longer supported, use "errorHandler" instead');
-        }
+        $this->phpVersion = $phpVersion ?? PhpVersion::getNewestSupported();
 
         $this->initReduceCallbacks();
+        $this->phpTokenToSymbol = $this->createTokenMap();
+        $this->dropTokens = array_fill_keys(
+            [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], true
+        );
     }
 
     /**
@@ -152,36 +175,55 @@ abstract class ParserAbstract implements Parser
      * @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) {
-        $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing;
+    public function parse(string $code, ?ErrorHandler $errorHandler = null): ?array {
+        $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing();
+        $this->createdArrays = new \SplObjectStorage();
 
-        $this->lexer->startLexing($code, $this->errorHandler);
+        $this->tokens = $this->lexer->tokenize($code, $this->errorHandler);
         $result = $this->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->createdArrays as $node) {
+            foreach ($node->items as $item) {
+                if ($item->value instanceof Expr\Error) {
+                    $this->errorHandler->handleError(
+                        new Error('Cannot use empty array elements in arrays', $item->getAttributes()));
+                }
+            }
+        }
+
         // Clear out some of the interior state, so we don't hold onto unnecessary
         // memory between uses of the parser
-        $this->startAttributeStack = [];
-        $this->endAttributeStack = [];
+        $this->tokenStartStack = [];
+        $this->tokenEndStack = [];
         $this->semStack = [];
         $this->semValue = null;
+        $this->createdArrays = null;
+
+        if ($result !== null) {
+            $traverser = new NodeTraverser(new CommentAnnotatingVisitor($this->tokens));
+            $traverser->traverse($result);
+        }
 
         return $result;
     }
 
-    protected function doParse() {
+    public function getTokens(): array {
+        return $this->tokens;
+    }
+
+    /** @return Stmt[]|null */
+    protected function doParse(): ?array {
         // We start off with no lookahead-token
         $symbol = self::SYMBOL_NONE;
-
-        // The attributes for a node are taken from the first and last token of the node.
-        // From the first token only the startAttributes are taken and from the last only
-        // the endAttributes. Both are merged using the array union operator (+).
-        $startAttributes = [];
-        $endAttributes = [];
-        $this->endAttributes = $endAttributes;
+        $tokenValue = null;
+        $this->tokenPos = -1;
 
         // Keep stack of start and end attributes
-        $this->startAttributeStack = [];
-        $this->endAttributeStack = [$endAttributes];
+        $this->tokenStartStack = [];
+        $this->tokenEndStack = [0];
 
         // Start off in the initial state and keep a stack of previous states
         $state = 0;
@@ -202,26 +244,20 @@ abstract class ParserAbstract implements Parser
                 $rule = $this->actionDefault[$state];
             } else {
                 if ($symbol === self::SYMBOL_NONE) {
-                    // Fetch the next token id from the lexer and fetch additional info by-ref.
-                    // The end attributes are fetched into a temporary variable and only set once the token is really
-                    // shifted (not during read). Otherwise you would sometimes get off-by-one errors, when a rule is
-                    // reduced after a token was read but not yet shifted.
-                    $tokenId = $this->lexer->getNextToken($tokenValue, $startAttributes, $endAttributes);
-
-                    // map the lexer token id to the internally used symbols
-                    $symbol = $tokenId >= 0 && $tokenId < $this->tokenToSymbolMapSize
-                        ? $this->tokenToSymbol[$tokenId]
-                        : $this->invalidSymbol;
-
-                    if ($symbol === $this->invalidSymbol) {
+                    do {
+                        $token = $this->tokens[++$this->tokenPos];
+                        $tokenId = $token->id;
+                    } while (isset($this->dropTokens[$tokenId]));
+
+                    // Map the lexer token id to the internally used symbols.
+                    $tokenValue = $token->text;
+                    if (!isset($this->phpTokenToSymbol[$tokenId])) {
                         throw new \RangeException(sprintf(
                             'The lexer returned an invalid token (id=%d, value=%s)',
                             $tokenId, $tokenValue
                         ));
                     }
-
-                    // Allow productions to access the start attributes of the lookahead token.
-                    $this->lookaheadStartAttributes = $startAttributes;
+                    $symbol = $this->phpTokenToSymbol[$tokenId];
 
                     //$this->traceRead($symbol);
                 }
@@ -246,9 +282,8 @@ abstract class ParserAbstract implements Parser
                         ++$stackPos;
                         $stateStack[$stackPos] = $state = $action;
                         $this->semStack[$stackPos] = $tokenValue;
-                        $this->startAttributeStack[$stackPos] = $startAttributes;
-                        $this->endAttributeStack[$stackPos] = $endAttributes;
-                        $this->endAttributes = $endAttributes;
+                        $this->tokenStartStack[$stackPos] = $this->tokenPos;
+                        $this->tokenEndStack[$stackPos] = $this->tokenPos;
                         $symbol = self::SYMBOL_NONE;
 
                         if ($this->errorState) {
@@ -274,15 +309,22 @@ abstract class ParserAbstract implements Parser
                     /* accept */
                     //$this->traceAccept();
                     return $this->semValue;
-                } elseif ($rule !== $this->unexpectedTokenRule) {
+                }
+                if ($rule !== $this->unexpectedTokenRule) {
                     /* reduce */
                     //$this->traceReduce($rule);
 
+                    $ruleLength = $this->ruleToLength[$rule];
                     try {
-                        $this->reduceCallbacks[$rule]($stackPos);
+                        $callback = $this->reduceCallbacks[$rule];
+                        if ($callback !== null) {
+                            $callback($this, $stackPos);
+                        } elseif ($ruleLength > 0) {
+                            $this->semValue = $this->semStack[$stackPos - $ruleLength + 1];
+                        }
                     } catch (Error $e) {
-                        if (-1 === $e->getStartLine() && isset($startAttributes['startLine'])) {
-                            $e->setStartLine($startAttributes['startLine']);
+                        if (-1 === $e->getStartLine()) {
+                            $e->setStartLine($this->tokens[$this->tokenPos]->line);
                         }
 
                         $this->emitError($e);
@@ -291,8 +333,7 @@ abstract class ParserAbstract implements Parser
                     }
 
                     /* Goto - shift nonterminal */
-                    $lastEndAttributes = $this->endAttributeStack[$stackPos];
-                    $ruleLength = $this->ruleToLength[$rule];
+                    $lastTokenEnd = $this->tokenEndStack[$stackPos];
                     $stackPos -= $ruleLength;
                     $nonTerminal = $this->ruleToNonTerminal[$rule];
                     $idx = $this->gotoBase[$nonTerminal] + $stateStack[$stackPos];
@@ -305,18 +346,19 @@ abstract class ParserAbstract implements Parser
                     ++$stackPos;
                     $stateStack[$stackPos]     = $state;
                     $this->semStack[$stackPos] = $this->semValue;
-                    $this->endAttributeStack[$stackPos] = $lastEndAttributes;
+                    $this->tokenEndStack[$stackPos] = $lastTokenEnd;
                     if ($ruleLength === 0) {
                         // Empty productions use the start attributes of the lookahead token.
-                        $this->startAttributeStack[$stackPos] = $this->lookaheadStartAttributes;
+                        $this->tokenStartStack[$stackPos] = $this->tokenPos;
                     }
                 } else {
                     /* error */
                     switch ($this->errorState) {
                         case 0:
                             $msg = $this->getErrorMessage($symbol, $state);
-                            $this->emitError(new Error($msg, $startAttributes + $endAttributes));
+                            $this->emitError(new Error($msg, $this->getAttributesForToken($this->tokenPos)));
                             // Break missing intentionally
+                            // no break
                         case 1:
                         case 2:
                             $this->errorState = 3;
@@ -343,9 +385,8 @@ abstract class ParserAbstract implements Parser
 
                             // 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->startAttributeStack[$stackPos] = $this->lookaheadStartAttributes;
-                            $this->endAttributeStack[$stackPos] = $this->endAttributeStack[$stackPos - 1];
-                            $this->endAttributes = $this->endAttributeStack[$stackPos - 1];
+                            $this->tokenStartStack[$stackPos] = $this->tokenPos;
+                            $this->tokenEndStack[$stackPos] = $this->tokenEndStack[$stackPos - 1];
                             break;
 
                         case 3:
@@ -372,7 +413,7 @@ abstract class ParserAbstract implements Parser
         throw new \RuntimeException('Reached end of parser loop');
     }
 
-    protected function emitError(Error $error) {
+    protected function emitError(Error $error): void {
         $this->errorHandler->handleError($error);
     }
 
@@ -380,11 +421,11 @@ abstract class ParserAbstract implements Parser
      * Format error message including expected tokens.
      *
      * @param int $symbol Unexpected symbol
-     * @param int $state  State at time of error
+     * @param int $state State at time of error
      *
      * @return string Formatted error message
      */
-    protected function getErrorMessage(int $symbol, int $state) : string {
+    protected function getErrorMessage(int $symbol, int $state): string {
         $expectedString = '';
         if ($expected = $this->getExpectedTokens($state)) {
             $expectedString = ', expecting ' . implode(' or ', $expected);
@@ -400,7 +441,7 @@ abstract class ParserAbstract implements Parser
      *
      * @return string[] Expected tokens. If too many, an empty array is returned.
      */
-    protected function getExpectedTokens(int $state) : array {
+    protected function getExpectedTokens(int $state): array {
         $expected = [];
 
         $base = $this->actionBase[$state];
@@ -428,37 +469,79 @@ abstract class ParserAbstract implements Parser
         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<string, mixed> Attributes
+     */
+    protected function getAttributes(int $tokenStartPos, int $tokenEndPos): array {
+        $startToken = $this->tokens[$tokenStartPos];
+        $afterEndToken = $this->tokens[$tokenEndPos + 1];
+        return [
+            'startLine' => $startToken->line,
+            'startTokenPos' => $tokenStartPos,
+            'startFilePos' => $startToken->pos,
+            'endLine' => $afterEndToken->line,
+            'endTokenPos' => $tokenEndPos,
+            'endFilePos' => $afterEndToken->pos - 1,
+        ];
+    }
+
+    /**
+     * Get attributes for a single token at the given token position.
+     *
+     * @return array<string, mixed> Attributes
+     */
+    protected function getAttributesForToken(int $tokenPos): array {
+        if ($tokenPos < \count($this->tokens) - 1) {
+            return $this->getAttributes($tokenPos, $tokenPos);
+        }
+
+        // Get attributes for the sentinel token.
+        $token = $this->tokens[$tokenPos];
+        return [
+            'startLine' => $token->line,
+            'startTokenPos' => $tokenPos,
+            'startFilePos' => $token->pos,
+            'endLine' => $token->line,
+            'endTokenPos' => $tokenPos,
+            'endFilePos' => $token->pos,
+        ];
+    }
+
     /*
      * Tracing functions used for debugging the parser.
      */
 
     /*
-    protected function traceNewState($state, $symbol) {
+    protected function traceNewState($state, $symbol): void {
         echo '% State ' . $state
             . ', Lookahead ' . ($symbol == self::SYMBOL_NONE ? '--none--' : $this->symbolToName[$symbol]) . "\n";
     }
 
-    protected function traceRead($symbol) {
+    protected function traceRead($symbol): void {
         echo '% Reading ' . $this->symbolToName[$symbol] . "\n";
     }
 
-    protected function traceShift($symbol) {
+    protected function traceShift($symbol): void {
         echo '% Shift ' . $this->symbolToName[$symbol] . "\n";
     }
 
-    protected function traceAccept() {
+    protected function traceAccept(): void {
         echo "% Accepted.\n";
     }
 
-    protected function traceReduce($n) {
+    protected function traceReduce($n): void {
         echo '% Reduce by (' . $n . ') ' . $this->productions[$n] . "\n";
     }
 
-    protected function tracePop($state) {
+    protected function tracePop($state): void {
         echo '% Recovering, uncovered state ' . $state . "\n";
     }
 
-    protected function traceDiscard($symbol) {
+    protected function traceDiscard($symbol): void {
         echo '% Discard ' . $this->symbolToName[$symbol] . "\n";
     }
     */
@@ -473,13 +556,14 @@ abstract class ParserAbstract implements Parser
      * @param Node\Stmt[] $stmts
      * @return Node\Stmt[]
      */
-    protected function handleNamespaces(array $stmts) : array {
+    protected function handleNamespaces(array $stmts): array {
         $hasErrored = false;
         $style = $this->getNamespacingStyle($stmts);
         if (null === $style) {
             // not namespaced, nothing to do
             return $stmts;
-        } elseif ('brace' === $style) {
+        }
+        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) {
@@ -497,7 +581,7 @@ abstract class ParserAbstract implements Parser
         } else {
             // For semicolon namespaces we have to move the statements after a namespace declaration into ->stmts
             $resultStmts = [];
-            $targetStmts =& $resultStmts;
+            $targetStmts = &$resultStmts;
             $lastNs = null;
             foreach ($stmts as $stmt) {
                 if ($stmt instanceof Node\Stmt\Namespace_) {
@@ -506,12 +590,12 @@ abstract class ParserAbstract implements Parser
                     }
                     if ($stmt->stmts === null) {
                         $stmt->stmts = [];
-                        $targetStmts =& $stmt->stmts;
+                        $targetStmts = &$stmt->stmts;
                         $resultStmts[] = $stmt;
                     } else {
                         // This handles the invalid case of mixed style namespaces
                         $resultStmts[] = $stmt;
-                        $targetStmts =& $resultStmts;
+                        $targetStmts = &$resultStmts;
                     }
                     $lastNs = $stmt;
                 } elseif ($stmt instanceof Node\Stmt\HaltCompiler) {
@@ -528,7 +612,7 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    private function fixupNamespaceAttributes(Node\Stmt\Namespace_ $stmt) {
+    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->stmts)) {
@@ -546,6 +630,22 @@ abstract class ParserAbstract implements Parser
         }
     }
 
+    /** @return array<string, mixed> */
+    private function getNamespaceErrorAttributes(Namespace_ $node): array {
+        $attrs = $node->getAttributes();
+        // Adjust end attributes to only cover the "namespace" 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)
      *
@@ -553,7 +653,7 @@ abstract class ParserAbstract implements Parser
      *
      * @return null|string One of "semicolon", "brace" or null (no namespaces)
      */
-    private function getNamespacingStyle(array $stmts) {
+    private function getNamespacingStyle(array $stmts): ?string {
         $style = null;
         $hasNotAllowedStmts = false;
         foreach ($stmts as $i => $stmt) {
@@ -564,13 +664,13 @@ abstract class ParserAbstract implements Parser
                     if ($hasNotAllowedStmts) {
                         $this->emitError(new Error(
                             'Namespace declaration statement has to be the very first statement in the script',
-                            $stmt->getLine() // Avoid marking the entire namespace as an error
+                            $this->getNamespaceErrorAttributes($stmt)
                         ));
                     }
                 } elseif ($style !== $currentStyle) {
                     $this->emitError(new Error(
                         'Cannot mix bracketed namespace declarations with unbracketed namespace declarations',
-                        $stmt->getLine() // Avoid marking the entire namespace as an error
+                        $this->getNamespaceErrorAttributes($stmt)
                     ));
                     // Treat like semicolon style for namespace normalization
                     return 'semicolon';
@@ -596,82 +696,14 @@ abstract class ParserAbstract implements Parser
         return $style;
     }
 
-    /**
-     * Fix up parsing of static property calls in PHP 5.
-     *
-     * In PHP 5 A::$b[c][d] and A::$b[c][d]() have very different interpretation. The former is
-     * interpreted as (A::$b)[c][d], while the latter is the same as A::{$b[c][d]}(). We parse the
-     * latter as the former initially and this method fixes the AST into the correct form when we
-     * encounter the "()".
-     *
-     * @param  Node\Expr\StaticPropertyFetch|Node\Expr\ArrayDimFetch $prop
-     * @param  Node\Arg[] $args
-     * @param  array      $attributes
-     *
-     * @return Expr\StaticCall
-     */
-    protected function fixupPhp5StaticPropCall($prop, array $args, array $attributes) : Expr\StaticCall {
-        if ($prop instanceof Node\Expr\StaticPropertyFetch) {
-            $name = $prop->name instanceof VarLikeIdentifier
-                ? $prop->name->toString() : $prop->name;
-            $var = new Expr\Variable($name, $prop->name->getAttributes());
-            return new Expr\StaticCall($prop->class, $var, $args, $attributes);
-        } elseif ($prop instanceof Node\Expr\ArrayDimFetch) {
-            $tmp = $prop;
-            while ($tmp->var instanceof Node\Expr\ArrayDimFetch) {
-                $tmp = $tmp->var;
-            }
-
-            /** @var Expr\StaticPropertyFetch $staticProp */
-            $staticProp = $tmp->var;
-
-            // Set start attributes to attributes of innermost node
-            $tmp = $prop;
-            $this->fixupStartAttributes($tmp, $staticProp->name);
-            while ($tmp->var instanceof Node\Expr\ArrayDimFetch) {
-                $tmp = $tmp->var;
-                $this->fixupStartAttributes($tmp, $staticProp->name);
-            }
-
-            $name = $staticProp->name instanceof VarLikeIdentifier
-                ? $staticProp->name->toString() : $staticProp->name;
-            $tmp->var = new Expr\Variable($name, $staticProp->name->getAttributes());
-            return new Expr\StaticCall($staticProp->class, $prop, $args, $attributes);
-        } else {
-            throw new \Exception;
-        }
-    }
-
-    protected function fixupStartAttributes(Node $to, Node $from) {
-        $startAttributes = ['startLine', 'startFilePos', 'startTokenPos'];
-        foreach ($startAttributes as $startAttribute) {
-            if ($from->hasAttribute($startAttribute)) {
-                $to->setAttribute($startAttribute, $from->getAttribute($startAttribute));
-            }
-        }
-    }
-
+    /** @return Name|Identifier */
     protected function handleBuiltinTypes(Name $name) {
-        $builtinTypes = [
-            'bool'     => true,
-            'int'      => true,
-            'float'    => true,
-            'string'   => true,
-            'iterable' => true,
-            'void'     => true,
-            'object'   => true,
-            'null'     => true,
-            'false'    => true,
-            'mixed'    => true,
-            'never'    => true,
-        ];
-
         if (!$name->isUnqualified()) {
             return $name;
         }
 
         $lowerName = $name->toLowerString();
-        if (!isset($builtinTypes[$lowerName])) {
+        if (!$this->phpVersion->supportsBuiltinType($lowerName)) {
             return $name;
         }
 
@@ -681,16 +713,15 @@ abstract class ParserAbstract implements Parser
     /**
      * Get combined start and end attributes at a stack location
      *
-     * @param int $pos Stack location
+     * @param int $stackPos Stack location
      *
-     * @return array Combined start and end attributes
+     * @return array<string, mixed> Combined start and end attributes
      */
-    protected function getAttributesAt(int $pos) : array {
-        return $this->startAttributeStack[$pos] + $this->endAttributeStack[$pos];
+    protected function getAttributesAt(int $stackPos): array {
+        return $this->getAttributes($this->tokenStartStack[$stackPos], $this->tokenEndStack[$stackPos]);
     }
 
-    protected function getFloatCastKind(string $cast): int
-    {
+    protected function getFloatCastKind(string $cast): int {
         $cast = strtolower($cast);
         if (strpos($cast, 'float') !== false) {
             return Double::KIND_FLOAT;
@@ -703,23 +734,24 @@ abstract class ParserAbstract implements Parser
         return Double::KIND_DOUBLE;
     }
 
-    protected function parseLNumber($str, $attributes, $allowInvalidOctal = false) {
+    /** @param array<string, mixed> $attributes */
+    protected function parseLNumber(string $str, array $attributes, bool $allowInvalidOctal = false): Int_ {
         try {
-            return LNumber::fromString($str, $attributes, $allowInvalidOctal);
+            return Int_::fromString($str, $attributes, $allowInvalidOctal);
         } catch (Error $error) {
             $this->emitError($error);
             // Use dummy value
-            return new LNumber(0, $attributes);
+            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  $attributes Attributes
+     * @param string $str Number string
+     * @param array<string, mixed> $attributes Attributes
      *
-     * @return LNumber|String_ Integer or string node.
+     * @return Int_|String_ Integer or string node.
      */
     protected function parseNumString(string $str, array $attributes) {
         if (!preg_match('/^(?:0|-?[1-9][0-9]*)$/', $str)) {
@@ -731,13 +763,14 @@ abstract class ParserAbstract implements Parser
             return new String_($str, $attributes);
         }
 
-        return new LNumber($num, $attributes);
+        return new Int_($num, $attributes);
     }
 
+    /** @param array<string, mixed> $attributes */
     protected function stripIndentation(
         string $string, int $indentLen, string $indentChar,
         bool $newlineAtStart, bool $newlineAtEnd, array $attributes
-    ) {
+    ): string {
         if ($indentLen === 0) {
             return $string;
         }
@@ -766,10 +799,15 @@ abstract class ParserAbstract implements Parser
         );
     }
 
+    /**
+     * @param string|(Expr|InterpolatedStringPart)[] $contents
+     * @param array<string, mixed> $attributes
+     * @param array<string, mixed> $endTokenAttributes
+     */
     protected function parseDocString(
         string $startToken, $contents, string $endToken,
         array $attributes, array $endTokenAttributes, bool $parseUnicodeEscape
-    ) {
+    ): Expr {
         $kind = strpos($startToken, "'") === false
             ? String_::KIND_HEREDOC : String_::KIND_NOWDOC;
 
@@ -803,6 +841,7 @@ abstract class ParserAbstract implements Parser
 
         if (\is_string($contents)) {
             if ($contents === '') {
+                $attributes['rawValue'] = $contents;
                 return new String_('', $attributes);
             }
 
@@ -810,6 +849,7 @@ abstract class ParserAbstract implements Parser
                 $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);
@@ -818,7 +858,7 @@ abstract class ParserAbstract implements Parser
             return new String_($contents, $attributes);
         } else {
             assert(count($contents) > 0);
-            if (!$contents[0] instanceof Node\Scalar\EncapsedStringPart) {
+            if (!$contents[0] instanceof Node\InterpolatedStringPart) {
                 // If there is no leading encapsed string part, pretend there is an empty one
                 $this->stripIndentation(
                     '', $indentLen, $indentChar, true, false, $contents[0]->getAttributes()
@@ -827,65 +867,175 @@ abstract class ParserAbstract implements Parser
 
             $newContents = [];
             foreach ($contents as $i => $part) {
-                if ($part instanceof Node\Scalar\EncapsedStringPart) {
+                if ($part instanceof Node\InterpolatedStringPart) {
                     $isLast = $i === \count($contents) - 1;
                     $part->value = $this->stripIndentation(
                         $part->value, $indentLen, $indentChar,
                         $i === 0, $isLast, $part->getAttributes()
                     );
-                    $part->value = String_::parseEscapeSequences($part->value, null, $parseUnicodeEscape);
                     if ($isLast) {
                         $part->value = preg_replace('~(\r\n|\n|\r)\z~', '', $part->value);
                     }
+                    $part->setAttribute('rawValue', $part->value);
+                    $part->value = String_::parseEscapeSequences($part->value, null, $parseUnicodeEscape);
                     if ('' === $part->value) {
                         continue;
                     }
                 }
                 $newContents[] = $part;
             }
-            return new Encapsed($newContents, $attributes);
+            return new InterpolatedString($newContents, $attributes);
         }
     }
 
+    protected function createCommentFromToken(Token $token, int $tokenPos): Comment {
+        assert($token->id === \T_COMMENT || $token->id == \T_DOC_COMMENT);
+        return \T_DOC_COMMENT === $token->id
+            ? new Comment\Doc($token->text, $token->line, $token->pos, $tokenPos,
+                $token->getEndLine(), $token->getEndPos() - 1, $tokenPos)
+            : new Comment($token->text, $token->line, $token->pos, $tokenPos,
+                $token->getEndLine(), $token->getEndPos() - 1, $tokenPos);
+    }
+
     /**
-     * Create attributes for a zero-length common-capturing nop.
-     *
-     * @param Comment[] $comments
-     * @return array
+     * Get last comment before the given token position, if any
      */
-    protected function createCommentNopAttributes(array $comments) {
-        $comment = $comments[count($comments) - 1];
+    protected function getCommentBeforeToken(int $tokenPos): ?Comment {
+        while (--$tokenPos >= 0) {
+            $token = $this->tokens[$tokenPos];
+            if (!isset($this->dropTokens[$token->id])) {
+                break;
+            }
+
+            if ($token->id === \T_COMMENT || $token->id === \T_DOC_COMMENT) {
+                return $this->createCommentFromToken($token, $tokenPos);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Create a zero-length nop to capture preceding comments, if any.
+     */
+    protected function maybeCreateZeroLengthNop(int $tokenPos): ?Nop {
+        $comment = $this->getCommentBeforeToken($tokenPos);
+        if ($comment === null) {
+            return null;
+        }
+
         $commentEndLine = $comment->getEndLine();
         $commentEndFilePos = $comment->getEndFilePos();
         $commentEndTokenPos = $comment->getEndTokenPos();
+        $attributes = [
+            'startLine' => $commentEndLine,
+            'endLine' => $commentEndLine,
+            'startFilePos' => $commentEndFilePos + 1,
+            'endFilePos' => $commentEndFilePos,
+            'startTokenPos' => $commentEndTokenPos + 1,
+            'endTokenPos' => $commentEndTokenPos,
+        ];
+        return new Nop($attributes);
+    }
 
-        $attributes = ['comments' => $comments];
-        if (-1 !== $commentEndLine) {
-            $attributes['startLine'] = $commentEndLine;
-            $attributes['endLine'] = $commentEndLine;
+    protected function maybeCreateNop(int $tokenStartPos, int $tokenEndPos): ?Nop {
+        if ($this->getCommentBeforeToken($tokenStartPos) === null) {
+            return null;
         }
-        if (-1 !== $commentEndFilePos) {
-            $attributes['startFilePos'] = $commentEndFilePos + 1;
-            $attributes['endFilePos'] = $commentEndFilePos;
+        return new Nop($this->getAttributes($tokenStartPos, $tokenEndPos));
+    }
+
+    protected function handleHaltCompiler(): string {
+        // Prevent the lexer from returning any further tokens.
+        $nextToken = $this->tokens[$this->tokenPos + 1];
+        $this->tokenPos = \count($this->tokens) - 2;
+
+        // Return text after __halt_compiler.
+        return $nextToken->id === \T_INLINE_HTML ? $nextToken->text : '';
+    }
+
+    protected function inlineHtmlHasLeadingNewline(int $stackPos): bool {
+        $tokenPos = $this->tokenStartStack[$stackPos];
+        $token = $this->tokens[$tokenPos];
+        assert($token->id == \T_INLINE_HTML);
+        if ($tokenPos > 0) {
+            $prevToken = $this->tokens[$tokenPos - 1];
+            assert($prevToken->id == \T_CLOSE_TAG);
+            return false !== strpos($prevToken->text, "\n")
+                || false !== strpos($prevToken->text, "\r");
         }
-        if (-1 !== $commentEndTokenPos) {
-            $attributes['startTokenPos'] = $commentEndTokenPos + 1;
-            $attributes['endTokenPos'] = $commentEndTokenPos;
+        return true;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    protected function createEmptyElemAttributes(int $tokenPos): array {
+        return $this->getAttributesForToken($tokenPos);
+    }
+
+    protected function fixupArrayDestructuring(Array_ $node): Expr\List_ {
+        $this->createdArrays->detach($node);
+        return new Expr\List_(array_map(function (Node\ArrayItem $item) {
+            if ($item->value instanceof Expr\Error) {
+                // We used Error as a placeholder for empty elements, which are legal for destructuring.
+                return null;
+            }
+            if ($item->value instanceof Array_) {
+                return new Node\ArrayItem(
+                    $this->fixupArrayDestructuring($item->value),
+                    $item->key, $item->byRef, $item->getAttributes());
+            }
+            return $item;
+        }, $node->items), ['kind' => Expr\List_::KIND_ARRAY] + $node->getAttributes());
+    }
+
+    protected function postprocessList(Expr\List_ $node): void {
+        foreach ($node->items as $i => $item) {
+            if ($item->value instanceof Expr\Error) {
+                // We used Error as a placeholder for empty elements, which are legal for destructuring.
+                $node->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->stmts);
+        if ($numStmts !== 0 && $node->stmts[$numStmts - 1] instanceof Nop) {
+            $nopAttrs = $node->stmts[$numStmts - 1]->getAttributes();
+            if (isset($nopAttrs['endLine'])) {
+                $node->setAttribute('endLine', $nopAttrs['endLine']);
+            }
+            if (isset($nopAttrs['endFilePos'])) {
+                $node->setAttribute('endFilePos', $nopAttrs['endFilePos']);
+            }
+            if (isset($nopAttrs['endTokenPos'])) {
+                $node->setAttribute('endTokenPos', $nopAttrs['endTokenPos']);
+            }
+        }
+    }
+
+    protected function checkClassModifier(int $a, int $b, int $modifierPos): void {
+        try {
+            Modifiers::verifyClassModifier($a, $b);
+        } catch (Error $error) {
+            $error->setAttributes($this->getAttributesAt($modifierPos));
+            $this->emitError($error);
         }
-        return $attributes;
     }
 
-    protected function checkModifier($a, $b, $modifierPos) {
+    protected function checkModifier(int $a, int $b, int $modifierPos): void {
         // Jumping through some hoops here because verifyModifier() is also used elsewhere
         try {
-            Class_::verifyModifier($a, $b);
+            Modifiers::verifyModifier($a, $b);
         } catch (Error $error) {
             $error->setAttributes($this->getAttributesAt($modifierPos));
             $this->emitError($error);
         }
     }
 
-    protected function checkParam(Param $node) {
+    protected function checkParam(Param $node): void {
         if ($node->variadic && null !== $node->default) {
             $this->emitError(new Error(
                 'Variadic parameter cannot have a default value',
@@ -894,7 +1044,7 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    protected function checkTryCatch(TryCatch $node) {
+    protected function checkTryCatch(TryCatch $node): void {
         if (empty($node->catches) && null === $node->finally) {
             $this->emitError(new Error(
                 'Cannot use try without catch or finally', $node->getAttributes()
@@ -902,7 +1052,7 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    protected function checkNamespace(Namespace_ $node) {
+    protected function checkNamespace(Namespace_ $node): void {
         if (null !== $node->stmts) {
             foreach ($node->stmts as $stmt) {
                 if ($stmt instanceof Namespace_) {
@@ -914,7 +1064,7 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    private function checkClassName($name, $namePos) {
+    private function checkClassName(?Identifier $name, int $namePos): void {
         if (null !== $name && $name->isSpecialClassName()) {
             $this->emitError(new Error(
                 sprintf('Cannot use \'%s\' as class name as it is reserved', $name),
@@ -923,7 +1073,8 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    private function checkImplementedInterfaces(array $interfaces) {
+    /** @param Name[] $interfaces */
+    private function checkImplementedInterfaces(array $interfaces): void {
         foreach ($interfaces as $interface) {
             if ($interface->isSpecialClassName()) {
                 $this->emitError(new Error(
@@ -934,7 +1085,7 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    protected function checkClass(Class_ $node, $namePos) {
+    protected function checkClass(Class_ $node, int $namePos): void {
         $this->checkClassName($node->name, $namePos);
 
         if ($node->extends && $node->extends->isSpecialClassName()) {
@@ -947,18 +1098,18 @@ abstract class ParserAbstract implements Parser
         $this->checkImplementedInterfaces($node->implements);
     }
 
-    protected function checkInterface(Interface_ $node, $namePos) {
+    protected function checkInterface(Interface_ $node, int $namePos): void {
         $this->checkClassName($node->name, $namePos);
         $this->checkImplementedInterfaces($node->extends);
     }
 
-    protected function checkEnum(Enum_ $node, $namePos) {
+    protected function checkEnum(Enum_ $node, int $namePos): void {
         $this->checkClassName($node->name, $namePos);
         $this->checkImplementedInterfaces($node->implements);
     }
 
-    protected function checkClassMethod(ClassMethod $node, $modifierPos) {
-        if ($node->flags & Class_::MODIFIER_STATIC) {
+    protected function checkClassMethod(ClassMethod $node, int $modifierPos): void {
+        if ($node->flags & Modifiers::STATIC) {
             switch ($node->name->toLowerString()) {
                 case '__construct':
                     $this->emitError(new Error(
@@ -977,39 +1128,45 @@ abstract class ParserAbstract implements Parser
                     break;
             }
         }
+
+        if ($node->flags & Modifiers::READONLY) {
+            $this->emitError(new Error(
+                sprintf('Method %s() cannot be readonly', $node->name),
+                $this->getAttributesAt($modifierPos)));
+        }
     }
 
-    protected function checkClassConst(ClassConst $node, $modifierPos) {
-        if ($node->flags & Class_::MODIFIER_STATIC) {
+    protected function checkClassConst(ClassConst $node, int $modifierPos): void {
+        if ($node->flags & Modifiers::STATIC) {
             $this->emitError(new Error(
                 "Cannot use 'static' as constant modifier",
                 $this->getAttributesAt($modifierPos)));
         }
-        if ($node->flags & Class_::MODIFIER_ABSTRACT) {
+        if ($node->flags & Modifiers::ABSTRACT) {
             $this->emitError(new Error(
                 "Cannot use 'abstract' as constant modifier",
                 $this->getAttributesAt($modifierPos)));
         }
-        if ($node->flags & Class_::MODIFIER_FINAL) {
+        if ($node->flags & Modifiers::READONLY) {
             $this->emitError(new Error(
-                "Cannot use 'final' as constant modifier",
+                "Cannot use 'readonly' as constant modifier",
                 $this->getAttributesAt($modifierPos)));
         }
     }
 
-    protected function checkProperty(Property $node, $modifierPos) {
-        if ($node->flags & Class_::MODIFIER_ABSTRACT) {
+    protected function checkProperty(Property $node, int $modifierPos): void {
+        if ($node->flags & Modifiers::ABSTRACT) {
             $this->emitError(new Error('Properties cannot be declared abstract',
                 $this->getAttributesAt($modifierPos)));
         }
 
-        if ($node->flags & Class_::MODIFIER_FINAL) {
+        if ($node->flags & Modifiers::FINAL) {
             $this->emitError(new Error('Properties cannot be declared final',
                 $this->getAttributesAt($modifierPos)));
         }
     }
 
-    protected function checkUseUse(UseUse $node, $namePos) {
+    protected function checkUseUse(UseItem $node, int $namePos): void {
         if ($node->alias && $node->alias->isSpecialClassName()) {
             $this->emitError(new Error(
                 sprintf(
@@ -1020,4 +1177,65 @@ abstract class ParserAbstract implements Parser
             ));
         }
     }
+
+    /**
+     * 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<int, int> The token map
+     */
+    protected function createTokenMap(): array {
+        $tokenMap = [];
+
+        for ($i = 0; $i < 1000; ++$i) {
+            if ($i < 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 => $extSymbol) {
+            $intSymbol = $this->tokenToSymbol[$extSymbol];
+            if ($intSymbol === $this->invalidSymbol) {
+                continue;
+            }
+            $fullTokenMap[$phpToken] = $intSymbol;
+        }
+
+        return $fullTokenMap;
+    }
 }