@atomicsmash/coding-standards 13.0.0-beta.3 → 13.0.0

package/vendor/squizlabs/php_codesniffer/src/Tokenizers/PHP.php

@@ -1,4005 +0,0 @@
-<?php
-/**
- * Tokenizes PHP code.
- *
- * @author    Greg Sherwood <gsherwood@squiz.net>
- * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600)
- * @license   https://github.com/PHPCSStandards/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
- */
-
-namespace PHP_CodeSniffer\Tokenizers;
-
-use PHP_CodeSniffer\Util\Common;
-use PHP_CodeSniffer\Util\Tokens;
-
-class PHP extends Tokenizer
-{
-
-    /**
-     * A list of tokens that are allowed to open a scope.
-     *
-     * This array also contains information about what kind of token the scope
-     * opener uses to open and close the scope, if the token strictly requires
-     * an opener, if the token can share a scope closer, and who it can be shared
-     * with. An example of a token that shares a scope closer is a CASE scope.
-     *
-     * @var array
-     */
-    public $scopeOpeners = [
-        T_IF            => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDIF               => T_ENDIF,
-                T_ELSE                => T_ELSE,
-                T_ELSEIF              => T_ELSEIF,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [
-                T_ELSE   => T_ELSE,
-                T_ELSEIF => T_ELSEIF,
-            ],
-        ],
-        T_TRY           => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_CATCH         => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_FINALLY       => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_ELSE          => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDIF               => T_ENDIF,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [
-                T_IF     => T_IF,
-                T_ELSEIF => T_ELSEIF,
-            ],
-        ],
-        T_ELSEIF        => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDIF               => T_ENDIF,
-                T_ELSE                => T_ELSE,
-                T_ELSEIF              => T_ELSEIF,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [
-                T_IF   => T_IF,
-                T_ELSE => T_ELSE,
-            ],
-        ],
-        T_FOR           => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDFOR              => T_ENDFOR,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_FOREACH       => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDFOREACH          => T_ENDFOREACH,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_INTERFACE     => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_FUNCTION      => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_CLASS         => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_TRAIT         => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_ENUM          => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_USE           => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_DECLARE       => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDDECLARE          => T_ENDDECLARE,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_NAMESPACE     => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_WHILE         => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDWHILE            => T_ENDWHILE,
-            ],
-            'strict' => false,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_DO            => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_SWITCH        => [
-            'start'  => [
-                T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET,
-                T_COLON              => T_COLON,
-            ],
-            'end'    => [
-                T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-                T_ENDSWITCH           => T_ENDSWITCH,
-            ],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_CASE          => [
-            'start'  => [
-                T_COLON     => T_COLON,
-                T_SEMICOLON => T_SEMICOLON,
-            ],
-            'end'    => [
-                T_BREAK    => T_BREAK,
-                T_RETURN   => T_RETURN,
-                T_CONTINUE => T_CONTINUE,
-                T_THROW    => T_THROW,
-                T_EXIT     => T_EXIT,
-            ],
-            'strict' => true,
-            'shared' => true,
-            'with'   => [
-                T_DEFAULT => T_DEFAULT,
-                T_CASE    => T_CASE,
-                T_SWITCH  => T_SWITCH,
-            ],
-        ],
-        T_DEFAULT       => [
-            'start'  => [
-                T_COLON     => T_COLON,
-                T_SEMICOLON => T_SEMICOLON,
-            ],
-            'end'    => [
-                T_BREAK    => T_BREAK,
-                T_RETURN   => T_RETURN,
-                T_CONTINUE => T_CONTINUE,
-                T_THROW    => T_THROW,
-                T_EXIT     => T_EXIT,
-            ],
-            'strict' => true,
-            'shared' => true,
-            'with'   => [
-                T_CASE   => T_CASE,
-                T_SWITCH => T_SWITCH,
-            ],
-        ],
-        T_MATCH         => [
-            'start'  => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET],
-            'end'    => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_START_HEREDOC => [
-            'start'  => [T_START_HEREDOC => T_START_HEREDOC],
-            'end'    => [T_END_HEREDOC => T_END_HEREDOC],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-        T_START_NOWDOC  => [
-            'start'  => [T_START_NOWDOC => T_START_NOWDOC],
-            'end'    => [T_END_NOWDOC => T_END_NOWDOC],
-            'strict' => true,
-            'shared' => false,
-            'with'   => [],
-        ],
-    ];
-
-    /**
-     * A list of tokens that end the scope.
-     *
-     * This array is just a unique collection of the end tokens
-     * from the scopeOpeners array. The data is duplicated here to
-     * save time during parsing of the file.
-     *
-     * @var array
-     */
-    public $endScopeTokens = [
-        T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET,
-        T_ENDIF               => T_ENDIF,
-        T_ENDFOR              => T_ENDFOR,
-        T_ENDFOREACH          => T_ENDFOREACH,
-        T_ENDWHILE            => T_ENDWHILE,
-        T_ENDSWITCH           => T_ENDSWITCH,
-        T_ENDDECLARE          => T_ENDDECLARE,
-        T_BREAK               => T_BREAK,
-        T_END_HEREDOC         => T_END_HEREDOC,
-        T_END_NOWDOC          => T_END_NOWDOC,
-    ];
-
-    /**
-     * Known lengths of tokens.
-     *
-     * @var array<string|int, int>
-     */
-    public $knownLengths = [
-        T_ABSTRACT                 => 8,
-        T_AND_EQUAL                => 2,
-        T_ARRAY                    => 5,
-        T_AS                       => 2,
-        T_BOOLEAN_AND              => 2,
-        T_BOOLEAN_OR               => 2,
-        T_BREAK                    => 5,
-        T_CALLABLE                 => 8,
-        T_CASE                     => 4,
-        T_CATCH                    => 5,
-        T_CLASS                    => 5,
-        T_CLASS_C                  => 9,
-        T_CLONE                    => 5,
-        T_CONCAT_EQUAL             => 2,
-        T_CONST                    => 5,
-        T_CONTINUE                 => 8,
-        T_CURLY_OPEN               => 2,
-        T_DEC                      => 2,
-        T_DECLARE                  => 7,
-        T_DEFAULT                  => 7,
-        T_DIR                      => 7,
-        T_DIV_EQUAL                => 2,
-        T_DO                       => 2,
-        T_DOLLAR_OPEN_CURLY_BRACES => 2,
-        T_DOUBLE_ARROW             => 2,
-        T_DOUBLE_COLON             => 2,
-        T_ECHO                     => 4,
-        T_ELLIPSIS                 => 3,
-        T_ELSE                     => 4,
-        T_ELSEIF                   => 6,
-        T_EMPTY                    => 5,
-        T_ENDDECLARE               => 10,
-        T_ENDFOR                   => 6,
-        T_ENDFOREACH               => 10,
-        T_ENDIF                    => 5,
-        T_ENDSWITCH                => 9,
-        T_ENDWHILE                 => 8,
-        T_ENUM                     => 4,
-        T_ENUM_CASE                => 4,
-        T_EVAL                     => 4,
-        T_EXTENDS                  => 7,
-        T_FILE                     => 8,
-        T_FINAL                    => 5,
-        T_FINALLY                  => 7,
-        T_FN                       => 2,
-        T_FOR                      => 3,
-        T_FOREACH                  => 7,
-        T_FUNCTION                 => 8,
-        T_FUNC_C                   => 12,
-        T_GLOBAL                   => 6,
-        T_GOTO                     => 4,
-        T_HALT_COMPILER            => 15,
-        T_IF                       => 2,
-        T_IMPLEMENTS               => 10,
-        T_INC                      => 2,
-        T_INCLUDE                  => 7,
-        T_INCLUDE_ONCE             => 12,
-        T_INSTANCEOF               => 10,
-        T_INSTEADOF                => 9,
-        T_INTERFACE                => 9,
-        T_ISSET                    => 5,
-        T_IS_EQUAL                 => 2,
-        T_IS_GREATER_OR_EQUAL      => 2,
-        T_IS_IDENTICAL             => 3,
-        T_IS_NOT_EQUAL             => 2,
-        T_IS_NOT_IDENTICAL         => 3,
-        T_IS_SMALLER_OR_EQUAL      => 2,
-        T_LINE                     => 8,
-        T_LIST                     => 4,
-        T_LOGICAL_AND              => 3,
-        T_LOGICAL_OR               => 2,
-        T_LOGICAL_XOR              => 3,
-        T_MATCH                    => 5,
-        T_MATCH_ARROW              => 2,
-        T_MATCH_DEFAULT            => 7,
-        T_METHOD_C                 => 10,
-        T_MINUS_EQUAL              => 2,
-        T_POW_EQUAL                => 3,
-        T_MOD_EQUAL                => 2,
-        T_MUL_EQUAL                => 2,
-        T_NAMESPACE                => 9,
-        T_NS_C                     => 13,
-        T_NS_SEPARATOR             => 1,
-        T_NEW                      => 3,
-        T_NULLSAFE_OBJECT_OPERATOR => 3,
-        T_OBJECT_OPERATOR          => 2,
-        T_OPEN_TAG_WITH_ECHO       => 3,
-        T_OR_EQUAL                 => 2,
-        T_PLUS_EQUAL               => 2,
-        T_PRINT                    => 5,
-        T_PRIVATE                  => 7,
-        T_PUBLIC                   => 6,
-        T_PROTECTED                => 9,
-        T_READONLY                 => 8,
-        T_REQUIRE                  => 7,
-        T_REQUIRE_ONCE             => 12,
-        T_RETURN                   => 6,
-        T_STATIC                   => 6,
-        T_SWITCH                   => 6,
-        T_THROW                    => 5,
-        T_TRAIT                    => 5,
-        T_TRAIT_C                  => 9,
-        T_TRY                      => 3,
-        T_UNSET                    => 5,
-        T_USE                      => 3,
-        T_VAR                      => 3,
-        T_WHILE                    => 5,
-        T_XOR_EQUAL                => 2,
-        T_YIELD                    => 5,
-        T_OPEN_CURLY_BRACKET       => 1,
-        T_CLOSE_CURLY_BRACKET      => 1,
-        T_OPEN_SQUARE_BRACKET      => 1,
-        T_CLOSE_SQUARE_BRACKET     => 1,
-        T_OPEN_PARENTHESIS         => 1,
-        T_CLOSE_PARENTHESIS        => 1,
-        T_COLON                    => 1,
-        T_STRING_CONCAT            => 1,
-        T_INLINE_THEN              => 1,
-        T_INLINE_ELSE              => 1,
-        T_NULLABLE                 => 1,
-        T_NULL                     => 4,
-        T_FALSE                    => 5,
-        T_TRUE                     => 4,
-        T_SEMICOLON                => 1,
-        T_EQUAL                    => 1,
-        T_MULTIPLY                 => 1,
-        T_DIVIDE                   => 1,
-        T_PLUS                     => 1,
-        T_MINUS                    => 1,
-        T_MODULUS                  => 1,
-        T_POW                      => 2,
-        T_SPACESHIP                => 3,
-        T_COALESCE                 => 2,
-        T_COALESCE_EQUAL           => 3,
-        T_BITWISE_AND              => 1,
-        T_BITWISE_OR               => 1,
-        T_BITWISE_XOR              => 1,
-        T_SL                       => 2,
-        T_SR                       => 2,
-        T_SL_EQUAL                 => 3,
-        T_SR_EQUAL                 => 3,
-        T_GREATER_THAN             => 1,
-        T_LESS_THAN                => 1,
-        T_BOOLEAN_NOT              => 1,
-        T_SELF                     => 4,
-        T_PARENT                   => 6,
-        T_COMMA                    => 1,
-        T_THIS                     => 4,
-        T_CLOSURE                  => 8,
-        T_BACKTICK                 => 1,
-        T_OPEN_SHORT_ARRAY         => 1,
-        T_CLOSE_SHORT_ARRAY        => 1,
-        T_TYPE_UNION               => 1,
-        T_TYPE_INTERSECTION        => 1,
-        T_TYPE_OPEN_PARENTHESIS    => 1,
-        T_TYPE_CLOSE_PARENTHESIS   => 1,
-    ];
-
-    /**
-     * Contexts in which keywords should always be tokenized as T_STRING.
-     *
-     * @var array
-     */
-    protected $tstringContexts = [
-        T_OBJECT_OPERATOR          => true,
-        T_NULLSAFE_OBJECT_OPERATOR => true,
-        T_FUNCTION                 => true,
-        T_CLASS                    => true,
-        T_INTERFACE                => true,
-        T_TRAIT                    => true,
-        T_ENUM                     => true,
-        T_ENUM_CASE                => true,
-        T_EXTENDS                  => true,
-        T_IMPLEMENTS               => true,
-        T_ATTRIBUTE                => true,
-        T_NEW                      => true,
-        T_CONST                    => true,
-        T_NS_SEPARATOR             => true,
-        T_USE                      => true,
-        T_NAMESPACE                => true,
-        T_PAAMAYIM_NEKUDOTAYIM     => true,
-    ];
-
-    /**
-     * A cache of different token types, resolved into arrays.
-     *
-     * @var array
-     * @see standardiseToken()
-     */
-    private static $resolveTokenCache = [];
-
-
-    /**
-     * Creates an array of tokens when given some PHP code.
-     *
-     * Starts by using token_get_all() but does a lot of extra processing
-     * to insert information about the context of the token.
-     *
-     * @param string $string The string to tokenize.
-     *
-     * @return array
-     */
-    protected function tokenize($string)
-    {
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            echo "\t*** START PHP TOKENIZING ***".PHP_EOL;
-            $isWin = false;
-            if (stripos(PHP_OS, 'WIN') === 0) {
-                $isWin = true;
-            }
-        }
-
-        $tokens      = @token_get_all($string);
-        $finalTokens = [];
-
-        $newStackPtr       = 0;
-        $numTokens         = count($tokens);
-        $lastNotEmptyToken = 0;
-
-        $insideInlineIf         = [];
-        $insideUseGroup         = false;
-        $insideConstDeclaration = false;
-
-        $commentTokenizer = new Comment();
-
-        for ($stackPtr = 0; $stackPtr < $numTokens; $stackPtr++) {
-            // Special case for tokens we have needed to blank out.
-            if ($tokens[$stackPtr] === null) {
-                continue;
-            }
-
-            $token        = (array) $tokens[$stackPtr];
-            $tokenIsArray = isset($token[1]);
-
-            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                if ($tokenIsArray === true) {
-                    $type    = Tokens::tokenName($token[0]);
-                    $content = Common::prepareForOutput($token[1]);
-                } else {
-                    $newToken = self::resolveSimpleToken($token[0]);
-                    $type     = $newToken['type'];
-                    $content  = Common::prepareForOutput($token[0]);
-                }
-
-                echo "\tProcess token ";
-                if ($tokenIsArray === true) {
-                    echo "[$stackPtr]";
-                } else {
-                    echo " $stackPtr ";
-                }
-
-                echo ": $type => $content";
-            }//end if
-
-            if ($newStackPtr > 0
-                && isset(Tokens::$emptyTokens[$finalTokens[($newStackPtr - 1)]['code']]) === false
-            ) {
-                $lastNotEmptyToken = ($newStackPtr - 1);
-            }
-
-            /*
-                If we are using \r\n newline characters, the \r and \n are sometimes
-                split over two tokens. This normally occurs after comments. We need
-                to merge these two characters together so that our line endings are
-                consistent for all lines.
-            */
-
-            if ($tokenIsArray === true && substr($token[1], -1) === "\r") {
-                if (isset($tokens[($stackPtr + 1)]) === true
-                    && is_array($tokens[($stackPtr + 1)]) === true
-                    && $tokens[($stackPtr + 1)][1][0] === "\n"
-                ) {
-                    $token[1] .= "\n";
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        if ($isWin === true) {
-                            echo '\n';
-                        } else {
-                            echo "\033[30;1m\\n\033[0m";
-                        }
-                    }
-
-                    if ($tokens[($stackPtr + 1)][1] === "\n") {
-                        // This token's content has been merged into the previous,
-                        // so we can skip it.
-                        $tokens[($stackPtr + 1)] = '';
-                    } else {
-                        $tokens[($stackPtr + 1)][1] = substr($tokens[($stackPtr + 1)][1], 1);
-                    }
-                }
-            }//end if
-
-            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                echo PHP_EOL;
-            }
-
-            /*
-                Before PHP 5.5, the yield keyword was tokenized as
-                T_STRING. So look for and change this token in
-                earlier versions.
-            */
-
-            if (PHP_VERSION_ID < 50500
-                && $tokenIsArray === true
-                && $token[0] === T_STRING
-                && strtolower($token[1]) === 'yield'
-                && isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === false
-            ) {
-                // Could still be a context sensitive keyword or "yield from" and potentially multi-line,
-                // so adjust the token stack in place.
-                $token[0] = T_YIELD;
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\t* token $stackPtr changed from T_STRING to T_YIELD".PHP_EOL;
-                }
-            }
-
-            /*
-                Tokenize context sensitive keyword as string when it should be string.
-            */
-
-            if ($tokenIsArray === true
-                && isset(Tokens::$contextSensitiveKeywords[$token[0]]) === true
-                && (isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === true
-                || $finalTokens[$lastNotEmptyToken]['content'] === '&'
-                || $insideConstDeclaration === true)
-            ) {
-                if (isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === true) {
-                    $preserveKeyword = false;
-
-                    // `new class`, and `new static` should be preserved.
-                    if ($finalTokens[$lastNotEmptyToken]['code'] === T_NEW
-                        && ($token[0] === T_CLASS
-                        || $token[0] === T_STATIC)
-                    ) {
-                        $preserveKeyword = true;
-                    }
-
-                    // `new readonly class` should be preserved.
-                    if ($finalTokens[$lastNotEmptyToken]['code'] === T_NEW
-                        && strtolower($token[1]) === 'readonly'
-                    ) {
-                        for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                            if (is_array($tokens[$i]) === false
-                                || isset(Tokens::$emptyTokens[$tokens[$i][0]]) === false
-                            ) {
-                                break;
-                            }
-                        }
-
-                        if (is_array($tokens[$i]) === true && $tokens[$i][0] === T_CLASS) {
-                            $preserveKeyword = true;
-                        }
-                    }
-
-                    // `new class extends` `new class implements` should be preserved
-                    if (($token[0] === T_EXTENDS || $token[0] === T_IMPLEMENTS)
-                        && $finalTokens[$lastNotEmptyToken]['code'] === T_CLASS
-                    ) {
-                        $preserveKeyword = true;
-                    }
-
-                    // `namespace\` should be preserved
-                    if ($token[0] === T_NAMESPACE) {
-                        for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                            if (is_array($tokens[$i]) === false) {
-                                break;
-                            }
-
-                            if (isset(Tokens::$emptyTokens[$tokens[$i][0]]) === true) {
-                                continue;
-                            }
-
-                            if ($tokens[$i][0] === T_NS_SEPARATOR) {
-                                $preserveKeyword = true;
-                            }
-
-                            break;
-                        }
-                    }
-                }//end if
-
-                // Types in typed constants should not be touched, but the constant name should be.
-                if ((isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === true
-                    && $finalTokens[$lastNotEmptyToken]['code'] === T_CONST)
-                    || $insideConstDeclaration === true
-                ) {
-                    $preserveKeyword = true;
-
-                    // Find the next non-empty token.
-                    for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                        if (is_array($tokens[$i]) === true
-                            && isset(Tokens::$emptyTokens[$tokens[$i][0]]) === true
-                        ) {
-                            continue;
-                        }
-
-                        break;
-                    }
-
-                    if ($tokens[$i] === '=' || $tokens[$i] === ';') {
-                        $preserveKeyword        = false;
-                        $insideConstDeclaration = false;
-                    }
-                }//end if
-
-                if ($finalTokens[$lastNotEmptyToken]['content'] === '&') {
-                    $preserveKeyword = true;
-
-                    for ($i = ($lastNotEmptyToken - 1); $i >= 0; $i--) {
-                        if (isset(Tokens::$emptyTokens[$finalTokens[$i]['code']]) === true) {
-                            continue;
-                        }
-
-                        if ($finalTokens[$i]['code'] === T_FUNCTION) {
-                            $preserveKeyword = false;
-                        }
-
-                        break;
-                    }
-                }
-
-                if ($preserveKeyword === false) {
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $type = Tokens::tokenName($token[0]);
-                        echo "\t\t* token $stackPtr changed from $type to T_STRING".PHP_EOL;
-                    }
-
-                    $finalTokens[$newStackPtr] = [
-                        'code'    => T_STRING,
-                        'type'    => 'T_STRING',
-                        'content' => $token[1],
-                    ];
-
-                    $newStackPtr++;
-                    continue;
-                }
-            }//end if
-
-            /*
-                Mark the start of a constant declaration to allow for handling keyword to T_STRING
-                convertion for constant names using reserved keywords.
-            */
-
-            if ($tokenIsArray === true && $token[0] === T_CONST) {
-                $insideConstDeclaration = true;
-            }
-
-            /*
-                Close an open "inside constant declaration" marker when no keyword conversion was needed.
-            */
-
-            if ($insideConstDeclaration === true
-                && $tokenIsArray === false
-                && ($token[0] === '=' || $token[0] === ';')
-            ) {
-                $insideConstDeclaration = false;
-            }
-
-            /*
-                Special case for `static` used as a function name, i.e. `static()`.
-
-                Note: this may incorrectly change the static keyword directly before a DNF property type.
-                If so, this will be caught and corrected for in the additional processing.
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_STATIC
-                && $finalTokens[$lastNotEmptyToken]['code'] !== T_NEW
-            ) {
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    if (is_array($tokens[$i]) === true
-                        && isset(Tokens::$emptyTokens[$tokens[$i][0]]) === true
-                    ) {
-                        continue;
-                    }
-
-                    if ($tokens[$i][0] === '(') {
-                        $finalTokens[$newStackPtr] = [
-                            'code'    => T_STRING,
-                            'type'    => 'T_STRING',
-                            'content' => $token[1],
-                        ];
-
-                        $newStackPtr++;
-                        continue 2;
-                    }
-
-                    break;
-                }
-            }//end if
-
-            /*
-                Parse doc blocks into something that can be easily iterated over.
-            */
-
-            if ($tokenIsArray === true
-                && ($token[0] === T_DOC_COMMENT
-                || ($token[0] === T_COMMENT && strpos($token[1], '/**') === 0 && $token[1] !== '/**/'))
-            ) {
-                $commentTokens = $commentTokenizer->tokenizeString($token[1], $this->eolChar, $newStackPtr);
-                foreach ($commentTokens as $commentToken) {
-                    $finalTokens[$newStackPtr] = $commentToken;
-                    $newStackPtr++;
-                }
-
-                continue;
-            }
-
-            /*
-                PHP 8 tokenizes a new line after a slash and hash comment to the next whitespace token.
-            */
-
-            if (PHP_VERSION_ID >= 80000
-                && $tokenIsArray === true
-                && ($token[0] === T_COMMENT && (strpos($token[1], '//') === 0 || strpos($token[1], '#') === 0))
-                && isset($tokens[($stackPtr + 1)]) === true
-                && is_array($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === T_WHITESPACE
-            ) {
-                $nextToken = $tokens[($stackPtr + 1)];
-
-                // If the next token is a single new line, merge it into the comment token
-                // and set to it up to be skipped.
-                if ($nextToken[1] === "\n" || $nextToken[1] === "\r\n" || $nextToken[1] === "\n\r") {
-                    $token[1] .= $nextToken[1];
-                    $tokens[($stackPtr + 1)] = null;
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* merged newline after comment into comment token $stackPtr".PHP_EOL;
-                    }
-                } else {
-                    // This may be a whitespace token consisting of multiple new lines.
-                    if (strpos($nextToken[1], "\r\n") === 0) {
-                        $token[1] .= "\r\n";
-                        $tokens[($stackPtr + 1)][1] = substr($nextToken[1], 2);
-                    } else if (strpos($nextToken[1], "\n\r") === 0) {
-                        $token[1] .= "\n\r";
-                        $tokens[($stackPtr + 1)][1] = substr($nextToken[1], 2);
-                    } else if (strpos($nextToken[1], "\n") === 0) {
-                        $token[1] .= "\n";
-                        $tokens[($stackPtr + 1)][1] = substr($nextToken[1], 1);
-                    }
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* stripped first newline after comment and added it to comment token $stackPtr".PHP_EOL;
-                    }
-                }//end if
-            }//end if
-
-            /*
-                For Explicit Octal Notation prior to PHP 8.1 we need to combine the
-                T_LNUMBER and T_STRING token values into a single token value, and
-                then ignore the T_STRING token.
-            */
-
-            if (PHP_VERSION_ID < 80100
-                && $tokenIsArray === true && $token[1] === '0'
-                && (isset($tokens[($stackPtr + 1)]) === true
-                && is_array($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === T_STRING
-                && isset($tokens[($stackPtr + 1)][1][0], $tokens[($stackPtr + 1)][1][1]) === true
-                && strtolower($tokens[($stackPtr + 1)][1][0]) === 'o'
-                && $tokens[($stackPtr + 1)][1][1] !== '_')
-                && preg_match('`^(o[0-7]+(?:_[0-7]+)?)([0-9_]*)$`i', $tokens[($stackPtr + 1)][1], $matches) === 1
-            ) {
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_LNUMBER,
-                    'type'    => 'T_LNUMBER',
-                    'content' => $token[1] .= $matches[1],
-                ];
-                $newStackPtr++;
-
-                if (isset($matches[2]) === true && $matches[2] !== '') {
-                    $type = 'T_LNUMBER';
-                    if ($matches[2][0] === '_') {
-                        $type = 'T_STRING';
-                    }
-
-                    $finalTokens[$newStackPtr] = [
-                        'code'    => constant($type),
-                        'type'    => $type,
-                        'content' => $matches[2],
-                    ];
-                    $newStackPtr++;
-                }
-
-                $stackPtr++;
-                continue;
-            }//end if
-
-            /*
-                PHP 8.1 introduced two dedicated tokens for the & character.
-                Retokenizing both of these to T_BITWISE_AND, which is the
-                token PHPCS already tokenized them as.
-            */
-
-            if ($tokenIsArray === true
-                && ($token[0] === T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
-                || $token[0] === T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG)
-            ) {
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_BITWISE_AND,
-                    'type'    => 'T_BITWISE_AND',
-                    'content' => $token[1],
-                ];
-                $newStackPtr++;
-                continue;
-            }
-
-            /*
-                If this is a double quoted string, PHP will tokenize the whole
-                thing which causes problems with the scope map when braces are
-                within the string. So we need to merge the tokens together to
-                provide a single string.
-            */
-
-            if ($tokenIsArray === false && ($token[0] === '"' || $token[0] === 'b"')) {
-                // Binary casts need a special token.
-                if ($token[0] === 'b"') {
-                    $finalTokens[$newStackPtr] = [
-                        'code'    => T_BINARY_CAST,
-                        'type'    => 'T_BINARY_CAST',
-                        'content' => 'b',
-                    ];
-                    $newStackPtr++;
-                }
-
-                $tokenContent = '"';
-                $nestedVars   = [];
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    $subToken        = (array) $tokens[$i];
-                    $subTokenIsArray = isset($subToken[1]);
-
-                    if ($subTokenIsArray === true) {
-                        $tokenContent .= $subToken[1];
-                        if (($subToken[1] === '{'
-                            || $subToken[1] === '${')
-                            && $subToken[0] !== T_ENCAPSED_AND_WHITESPACE
-                        ) {
-                            $nestedVars[] = $i;
-                        }
-                    } else {
-                        $tokenContent .= $subToken[0];
-                        if ($subToken[0] === '}') {
-                            array_pop($nestedVars);
-                        }
-                    }
-
-                    if ($subTokenIsArray === false
-                        && $subToken[0] === '"'
-                        && empty($nestedVars) === true
-                    ) {
-                        // We found the other end of the double quoted string.
-                        break;
-                    }
-                }//end for
-
-                $stackPtr = $i;
-
-                // Convert each line within the double quoted string to a
-                // new token, so it conforms with other multiple line tokens.
-                $tokenLines = explode($this->eolChar, $tokenContent);
-                $numLines   = count($tokenLines);
-                $newToken   = [];
-
-                for ($j = 0; $j < $numLines; $j++) {
-                    $newToken['content'] = $tokenLines[$j];
-                    if ($j === ($numLines - 1)) {
-                        if ($tokenLines[$j] === '') {
-                            break;
-                        }
-                    } else {
-                        $newToken['content'] .= $this->eolChar;
-                    }
-
-                    $newToken['code']          = T_DOUBLE_QUOTED_STRING;
-                    $newToken['type']          = 'T_DOUBLE_QUOTED_STRING';
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                }
-
-                // Continue, as we're done with this token.
-                continue;
-            }//end if
-
-            /*
-                Detect binary casting and assign the casts their own token.
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_CONSTANT_ENCAPSED_STRING
-                && (substr($token[1], 0, 2) === 'b"'
-                || substr($token[1], 0, 2) === "b'")
-            ) {
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_BINARY_CAST,
-                    'type'    => 'T_BINARY_CAST',
-                    'content' => 'b',
-                ];
-                $newStackPtr++;
-                $token[1] = substr($token[1], 1);
-            }
-
-            if ($tokenIsArray === true
-                && $token[0] === T_STRING_CAST
-                && preg_match('`^\(\s*binary\s*\)$`i', $token[1]) === 1
-            ) {
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_BINARY_CAST,
-                    'type'    => 'T_BINARY_CAST',
-                    'content' => $token[1],
-                ];
-                $newStackPtr++;
-                continue;
-            }
-
-            /*
-                If this is a heredoc, PHP will tokenize the whole
-                thing which causes problems when heredocs don't
-                contain real PHP code, which is almost never.
-                We want to leave the start and end heredoc tokens
-                alone though.
-            */
-
-            if ($tokenIsArray === true && $token[0] === T_START_HEREDOC) {
-                // Add the start heredoc token to the final array.
-                $finalTokens[$newStackPtr] = self::standardiseToken($token);
-
-                // Check if this is actually a nowdoc and use a different token
-                // to help the sniffs.
-                $nowdoc = false;
-                if (strpos($token[1], "'") !== false) {
-                    $finalTokens[$newStackPtr]['code'] = T_START_NOWDOC;
-                    $finalTokens[$newStackPtr]['type'] = 'T_START_NOWDOC';
-                    $nowdoc = true;
-                }
-
-                $tokenContent = '';
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    $subTokenIsArray = is_array($tokens[$i]);
-                    if ($subTokenIsArray === true
-                        && $tokens[$i][0] === T_END_HEREDOC
-                    ) {
-                        // We found the other end of the heredoc.
-                        break;
-                    }
-
-                    if ($subTokenIsArray === true) {
-                        $tokenContent .= $tokens[$i][1];
-                    } else {
-                        $tokenContent .= $tokens[$i];
-                    }
-                }
-
-                if ($i === $numTokens) {
-                    // We got to the end of the file and never
-                    // found the closing token, so this probably wasn't
-                    // a heredoc.
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $type = $finalTokens[$newStackPtr]['type'];
-                        echo "\t\t* failed to find the end of the here/nowdoc".PHP_EOL;
-                        echo "\t\t* token $stackPtr changed from $type to T_STRING".PHP_EOL;
-                    }
-
-                    $finalTokens[$newStackPtr]['code'] = T_STRING;
-                    $finalTokens[$newStackPtr]['type'] = 'T_STRING';
-                    $newStackPtr++;
-                    continue;
-                }
-
-                $stackPtr = $i;
-                $newStackPtr++;
-
-                // Convert each line within the heredoc to a
-                // new token, so it conforms with other multiple line tokens.
-                $tokenLines = explode($this->eolChar, $tokenContent);
-                $numLines   = count($tokenLines);
-                $newToken   = [];
-
-                for ($j = 0; $j < $numLines; $j++) {
-                    $newToken['content'] = $tokenLines[$j];
-                    if ($j === ($numLines - 1)) {
-                        if ($tokenLines[$j] === '') {
-                            break;
-                        }
-                    } else {
-                        $newToken['content'] .= $this->eolChar;
-                    }
-
-                    if ($nowdoc === true) {
-                        $newToken['code'] = T_NOWDOC;
-                        $newToken['type'] = 'T_NOWDOC';
-                    } else {
-                        $newToken['code'] = T_HEREDOC;
-                        $newToken['type'] = 'T_HEREDOC';
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                }//end for
-
-                // Add the end heredoc token to the final array.
-                $finalTokens[$newStackPtr] = self::standardiseToken($tokens[$stackPtr]);
-
-                if ($nowdoc === true) {
-                    $finalTokens[$newStackPtr]['code'] = T_END_NOWDOC;
-                    $finalTokens[$newStackPtr]['type'] = 'T_END_NOWDOC';
-                }
-
-                $newStackPtr++;
-
-                // Continue, as we're done with this token.
-                continue;
-            }//end if
-
-            /*
-                Enum keyword for PHP < 8.1
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_STRING
-                && strtolower($token[1]) === 'enum'
-            ) {
-                // Get the next non-empty token.
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    if (is_array($tokens[$i]) === false
-                        || isset(Tokens::$emptyTokens[$tokens[$i][0]]) === false
-                    ) {
-                        break;
-                    }
-                }
-
-                if (isset($tokens[$i]) === true
-                    && is_array($tokens[$i]) === true
-                    && $tokens[$i][0] === T_STRING
-                ) {
-                    // Modify $tokens directly so we can use it later when converting enum "case".
-                    $tokens[$stackPtr][0] = T_ENUM;
-
-                    $newToken            = [];
-                    $newToken['code']    = T_ENUM;
-                    $newToken['type']    = 'T_ENUM';
-                    $newToken['content'] = $token[1];
-                    $finalTokens[$newStackPtr] = $newToken;
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from T_STRING to T_ENUM".PHP_EOL;
-                    }
-
-                    $newStackPtr++;
-                    continue;
-                }
-            }//end if
-
-            /*
-                Convert enum "case" to T_ENUM_CASE
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_CASE
-                && isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === false
-            ) {
-                $isEnumCase = false;
-                $scope      = 1;
-
-                for ($i = ($stackPtr - 1); $i > 0; $i--) {
-                    if ($tokens[$i] === '}') {
-                        $scope++;
-                        continue;
-                    }
-
-                    if ($tokens[$i] === '{') {
-                        $scope--;
-                        continue;
-                    }
-
-                    if (is_array($tokens[$i]) === false) {
-                        continue;
-                    }
-
-                    if ($scope !== 0) {
-                        continue;
-                    }
-
-                    if ($tokens[$i][0] === T_SWITCH) {
-                        break;
-                    }
-
-                    if ($tokens[$i][0] === T_ENUM || $tokens[$i][0] === T_ENUM_CASE) {
-                        $isEnumCase = true;
-                        break;
-                    }
-                }//end for
-
-                if ($isEnumCase === true) {
-                    // Modify $tokens directly so we can use it as optimisation for other enum "case".
-                    $tokens[$stackPtr][0] = T_ENUM_CASE;
-
-                    $newToken            = [];
-                    $newToken['code']    = T_ENUM_CASE;
-                    $newToken['type']    = 'T_ENUM_CASE';
-                    $newToken['content'] = $token[1];
-                    $finalTokens[$newStackPtr] = $newToken;
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from T_CASE to T_ENUM_CASE".PHP_EOL;
-                    }
-
-                    $newStackPtr++;
-                    continue;
-                }
-            }//end if
-
-            /*
-                As of PHP 8.0 fully qualified, partially qualified and namespace relative
-                identifier names are tokenized differently.
-                This "undoes" the new tokenization so the tokenization will be the same in
-                in PHP 5, 7 and 8.
-            */
-
-            if (PHP_VERSION_ID >= 80000
-                && $tokenIsArray === true
-                && ($token[0] === T_NAME_QUALIFIED
-                || $token[0] === T_NAME_FULLY_QUALIFIED
-                || $token[0] === T_NAME_RELATIVE)
-            ) {
-                $name = $token[1];
-
-                if ($token[0] === T_NAME_FULLY_QUALIFIED) {
-                    $newToken            = [];
-                    $newToken['code']    = T_NS_SEPARATOR;
-                    $newToken['type']    = 'T_NS_SEPARATOR';
-                    $newToken['content'] = '\\';
-                    $finalTokens[$newStackPtr] = $newToken;
-                    ++$newStackPtr;
-
-                    $name = ltrim($name, '\\');
-                }
-
-                if ($token[0] === T_NAME_RELATIVE) {
-                    $newToken            = [];
-                    $newToken['code']    = T_NAMESPACE;
-                    $newToken['type']    = 'T_NAMESPACE';
-                    $newToken['content'] = substr($name, 0, 9);
-                    $finalTokens[$newStackPtr] = $newToken;
-                    ++$newStackPtr;
-
-                    $newToken            = [];
-                    $newToken['code']    = T_NS_SEPARATOR;
-                    $newToken['type']    = 'T_NS_SEPARATOR';
-                    $newToken['content'] = '\\';
-                    $finalTokens[$newStackPtr] = $newToken;
-                    ++$newStackPtr;
-
-                    $name = substr($name, 10);
-                }
-
-                $parts     = explode('\\', $name);
-                $partCount = count($parts);
-                $lastPart  = ($partCount - 1);
-
-                foreach ($parts as $i => $part) {
-                    $newToken            = [];
-                    $newToken['code']    = T_STRING;
-                    $newToken['type']    = 'T_STRING';
-                    $newToken['content'] = $part;
-                    $finalTokens[$newStackPtr] = $newToken;
-                    ++$newStackPtr;
-
-                    if ($i !== $lastPart) {
-                        $newToken            = [];
-                        $newToken['code']    = T_NS_SEPARATOR;
-                        $newToken['type']    = 'T_NS_SEPARATOR';
-                        $newToken['content'] = '\\';
-                        $finalTokens[$newStackPtr] = $newToken;
-                        ++$newStackPtr;
-                    }
-                }
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    $type    = Tokens::tokenName($token[0]);
-                    $content = Common::prepareForOutput($token[1]);
-                    echo "\t\t* token $stackPtr split into individual tokens; was: $type => $content".PHP_EOL;
-                }
-
-                continue;
-            }//end if
-
-            /*
-                PHP 8.0 Attributes
-            */
-
-            if (PHP_VERSION_ID < 80000
-                && $token[0] === T_COMMENT
-                && strpos($token[1], '#[') === 0
-            ) {
-                $subTokens = $this->parsePhpAttribute($tokens, $stackPtr);
-                if ($subTokens !== null) {
-                    array_splice($tokens, $stackPtr, 1, $subTokens);
-                    $numTokens = count($tokens);
-
-                    $tokenIsArray = true;
-                    $token        = $tokens[$stackPtr];
-                } else {
-                    $token[0] = T_ATTRIBUTE;
-                }
-            }
-
-            if ($tokenIsArray === true
-                && $token[0] === T_ATTRIBUTE
-            ) {
-                // Go looking for the close bracket.
-                $bracketCloser = $this->findCloser($tokens, ($stackPtr + 1), ['[', '#['], ']');
-
-                $newToken            = [];
-                $newToken['code']    = T_ATTRIBUTE;
-                $newToken['type']    = 'T_ATTRIBUTE';
-                $newToken['content'] = '#[';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $tokens[$bracketCloser]    = [];
-                $tokens[$bracketCloser][0] = T_ATTRIBUTE_END;
-                $tokens[$bracketCloser][1] = ']';
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\t* token $bracketCloser changed from T_CLOSE_SQUARE_BRACKET to T_ATTRIBUTE_END".PHP_EOL;
-                }
-
-                $newStackPtr++;
-                continue;
-            }//end if
-
-            /*
-                Tokenize the parameter labels for PHP 8.0 named parameters as a special T_PARAM_NAME
-                token and ensures that the colon after it is always T_COLON.
-            */
-
-            if ($tokenIsArray === true
-                && ($token[0] === T_STRING
-                || preg_match('`^[a-zA-Z_\x80-\xff]`', $token[1]) === 1)
-            ) {
-                // Get the next non-empty token.
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    if (is_array($tokens[$i]) === false
-                        || isset(Tokens::$emptyTokens[$tokens[$i][0]]) === false
-                    ) {
-                        break;
-                    }
-                }
-
-                if (isset($tokens[$i]) === true
-                    && is_array($tokens[$i]) === false
-                    && $tokens[$i] === ':'
-                ) {
-                    // Get the previous non-empty token.
-                    for ($j = ($stackPtr - 1); $j > 0; $j--) {
-                        if (is_array($tokens[$j]) === false
-                            || isset(Tokens::$emptyTokens[$tokens[$j][0]]) === false
-                        ) {
-                            break;
-                        }
-                    }
-
-                    if (is_array($tokens[$j]) === false
-                        && ($tokens[$j] === '('
-                        || $tokens[$j] === ',')
-                    ) {
-                        $newToken            = [];
-                        $newToken['code']    = T_PARAM_NAME;
-                        $newToken['type']    = 'T_PARAM_NAME';
-                        $newToken['content'] = $token[1];
-                        $finalTokens[$newStackPtr] = $newToken;
-
-                        $newStackPtr++;
-
-                        // Modify the original token stack so that future checks, like
-                        // determining T_COLON vs T_INLINE_ELSE can handle this correctly.
-                        $tokens[$stackPtr][0] = T_PARAM_NAME;
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $type = Tokens::tokenName($token[0]);
-                            echo "\t\t* token $stackPtr changed from $type to T_PARAM_NAME".PHP_EOL;
-                        }
-
-                        continue;
-                    }
-                }//end if
-            }//end if
-
-            /*
-                "readonly" keyword for PHP < 8.1
-            */
-
-            if ($tokenIsArray === true
-                && strtolower($token[1]) === 'readonly'
-                && (isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === false
-                || $finalTokens[$lastNotEmptyToken]['code'] === T_NEW)
-            ) {
-                // Get the next non-whitespace token.
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    if (is_array($tokens[$i]) === false
-                        || isset(Tokens::$emptyTokens[$tokens[$i][0]]) === false
-                    ) {
-                        break;
-                    }
-                }
-
-                $isReadonlyKeyword = false;
-
-                if (isset($tokens[$i]) === false
-                    || $tokens[$i] !== '('
-                ) {
-                    $isReadonlyKeyword = true;
-                } else if ($tokens[$i] === '(') {
-                    /*
-                     * Skip over tokens which can be used in type declarations.
-                     * At this point, the only token types which need to be taken into consideration
-                     * as potential type declarations are identifier names, T_ARRAY, T_CALLABLE and T_NS_SEPARATOR
-                     * and the union/intersection/dnf parentheses.
-                     */
-
-                    $foundDNFParens = 1;
-                    $foundDNFPipe   = 0;
-
-                    for (++$i; $i < $numTokens; $i++) {
-                        if (is_array($tokens[$i]) === true) {
-                            $tokenType = $tokens[$i][0];
-                        } else {
-                            $tokenType = $tokens[$i];
-                        }
-
-                        if (isset(Tokens::$emptyTokens[$tokenType]) === true) {
-                            continue;
-                        }
-
-                        if ($tokenType === '|') {
-                            ++$foundDNFPipe;
-                            continue;
-                        }
-
-                        if ($tokenType === ')') {
-                            ++$foundDNFParens;
-                            continue;
-                        }
-
-                        if ($tokenType === '(') {
-                            ++$foundDNFParens;
-                            continue;
-                        }
-
-                        if ($tokenType === T_STRING
-                            || $tokenType === T_NAME_FULLY_QUALIFIED
-                            || $tokenType === T_NAME_RELATIVE
-                            || $tokenType === T_NAME_QUALIFIED
-                            || $tokenType === T_ARRAY
-                            || $tokenType === T_NAMESPACE
-                            || $tokenType === T_NS_SEPARATOR
-                            || $tokenType === T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG // PHP 8.0+.
-                            || $tokenType === '&' // PHP < 8.0.
-                        ) {
-                            continue;
-                        }
-
-                        // Reached the next token after.
-                        if (($foundDNFParens % 2) === 0
-                            && $foundDNFPipe >= 1
-                            && ($tokenType === T_VARIABLE
-                            || $tokenType === T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG)
-                        ) {
-                            $isReadonlyKeyword = true;
-                        }
-
-                        break;
-                    }//end for
-                }//end if
-
-                if ($isReadonlyKeyword === true) {
-                    $finalTokens[$newStackPtr] = [
-                        'code'    => T_READONLY,
-                        'type'    => 'T_READONLY',
-                        'content' => $token[1],
-                    ];
-                    $newStackPtr++;
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1 && $type !== T_READONLY) {
-                        echo "\t\t* token $stackPtr changed from $type to T_READONLY".PHP_EOL;
-                    }
-                } else {
-                    $finalTokens[$newStackPtr] = [
-                        'code'    => T_STRING,
-                        'type'    => 'T_STRING',
-                        'content' => $token[1],
-                    ];
-                    $newStackPtr++;
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1 && $type !== T_STRING) {
-                        echo "\t\t* token $stackPtr changed from $type to T_STRING".PHP_EOL;
-                    }
-                }//end if
-
-                continue;
-            }//end if
-
-            /*
-                Before PHP 7.0, "yield from" was tokenized as
-                T_YIELD, T_WHITESPACE and T_STRING. So look for
-                and change this token in earlier versions.
-            */
-
-            if (PHP_VERSION_ID < 70000
-                && $tokenIsArray === true
-                && $token[0] === T_YIELD
-                && isset($tokens[($stackPtr + 1)]) === true
-                && isset($tokens[($stackPtr + 2)]) === true
-                && $tokens[($stackPtr + 1)][0] === T_WHITESPACE
-                && strpos($tokens[($stackPtr + 1)][1], $this->eolChar) === false
-                && $tokens[($stackPtr + 2)][0] === T_STRING
-                && strtolower($tokens[($stackPtr + 2)][1]) === 'from'
-            ) {
-                // Single-line "yield from" with only whitespace between.
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_YIELD_FROM,
-                    'type'    => 'T_YIELD_FROM',
-                    'content' => $token[1].$tokens[($stackPtr + 1)][1].$tokens[($stackPtr + 2)][1],
-                ];
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    for ($i = ($stackPtr + 1); $i <= ($stackPtr + 2); $i++) {
-                        $type    = Tokens::tokenName($tokens[$i][0]);
-                        $content = Common::prepareForOutput($tokens[$i][1]);
-                        echo "\t\t* token $i merged into T_YIELD_FROM; was: $type => $content".PHP_EOL;
-                    }
-                }
-
-                $newStackPtr++;
-                $stackPtr += 2;
-
-                continue;
-            } else if (PHP_VERSION_ID < 80300
-                && $tokenIsArray === true
-                && $token[0] === T_STRING
-                && strtolower($token[1]) === 'from'
-                && $finalTokens[$lastNotEmptyToken]['code'] === T_YIELD
-            ) {
-                /*
-                    Before PHP 8.3, if there was a comment between the "yield" and "from" keywords,
-                    it was tokenized as T_YIELD, T_WHITESPACE, T_COMMENT... and T_STRING.
-                    We want to keep the tokenization of the tokens between, but need to change the
-                    `T_YIELD` and `T_STRING` (from) keywords to `T_YIELD_FROM.
-                */
-
-                $finalTokens[$lastNotEmptyToken]['code'] = T_YIELD_FROM;
-                $finalTokens[$lastNotEmptyToken]['type'] = 'T_YIELD_FROM';
-
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_YIELD_FROM,
-                    'type'    => 'T_YIELD_FROM',
-                    'content' => $token[1],
-                ];
-                $newStackPtr++;
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\t* token $lastNotEmptyToken (new stack) changed into T_YIELD_FROM; was: T_YIELD".PHP_EOL;
-                    echo "\t\t* token $stackPtr changed into T_YIELD_FROM; was: T_STRING".PHP_EOL;
-                }
-
-                continue;
-            } else if (PHP_VERSION_ID >= 70000
-                && $tokenIsArray === true
-                && $token[0] === T_YIELD_FROM
-                && strpos($token[1], $this->eolChar) !== false
-                && preg_match('`^yield\s+from$`i', $token[1]) === 1
-            ) {
-                /*
-                    In PHP 7.0+, a multi-line "yield from" (without comment) tokenizes as a single
-                    T_YIELD_FROM token, but we want to split it and tokenize the whitespace
-                    separately for consistency.
-                */
-
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_YIELD_FROM,
-                    'type'    => 'T_YIELD_FROM',
-                    'content' => substr($token[1], 0, 5),
-                ];
-                $newStackPtr++;
-
-                $tokenLines = explode($this->eolChar, substr($token[1], 5, -4));
-                $numLines   = count($tokenLines);
-                $newToken   = [
-                    'type'    => 'T_WHITESPACE',
-                    'code'    => T_WHITESPACE,
-                    'content' => '',
-                ];
-
-                foreach ($tokenLines as $i => $line) {
-                    $newToken['content'] = $line;
-                    if ($i === ($numLines - 1)) {
-                        if ($line === '') {
-                            break;
-                        }
-                    } else {
-                        $newToken['content'] .= $this->eolChar;
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                }
-
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_YIELD_FROM,
-                    'type'    => 'T_YIELD_FROM',
-                    'content' => substr($token[1], -4),
-                ];
-                $newStackPtr++;
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\t* token $stackPtr split into 'yield', one or more whitespace tokens and 'from'".PHP_EOL;
-                }
-
-                continue;
-            } else if (PHP_VERSION_ID >= 80300
-                && $tokenIsArray === true
-                && $token[0] === T_YIELD_FROM
-                && preg_match('`^yield[ \t]+from$`i', $token[1]) !== 1
-                && stripos($token[1], 'yield') === 0
-            ) {
-                /*
-                    Since PHP 8.3, "yield from" allows for comments and will
-                    swallow the comment in the `T_YIELD_FROM` token.
-                    We need to split this up to allow for sniffs handling comments.
-                */
-
-                $finalTokens[$newStackPtr] = [
-                    'code'    => T_YIELD_FROM,
-                    'type'    => 'T_YIELD_FROM',
-                    'content' => substr($token[1], 0, 5),
-                ];
-                $newStackPtr++;
-
-                $yieldFromSubtokens = @token_get_all("<?php\n".substr($token[1], 5, -4));
-                // Remove the PHP open tag token.
-                array_shift($yieldFromSubtokens);
-                // Add the "from" keyword.
-                $yieldFromSubtokens[] = [
-                    0 => T_YIELD_FROM,
-                    1 => substr($token[1], -4),
-                ];
-
-                // Inject the new tokens into the token stack.
-                array_splice($tokens, ($stackPtr + 1), 0, $yieldFromSubtokens);
-                $numTokens = count($tokens);
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\t* token $stackPtr split into parts (yield from with comment)".PHP_EOL;
-                }
-
-                unset($yieldFromSubtokens);
-                continue;
-            }//end if
-
-            /*
-                Before PHP 5.6, the ... operator was tokenized as three
-                T_STRING_CONCAT tokens in a row. So look for and combine
-                these tokens in earlier versions.
-            */
-
-            if ($tokenIsArray === false
-                && $token[0] === '.'
-                && isset($tokens[($stackPtr + 1)]) === true
-                && isset($tokens[($stackPtr + 2)]) === true
-                && $tokens[($stackPtr + 1)] === '.'
-                && $tokens[($stackPtr + 2)] === '.'
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_ELLIPSIS;
-                $newToken['type']    = 'T_ELLIPSIS';
-                $newToken['content'] = '...';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr += 2;
-                continue;
-            }
-
-            /*
-                Before PHP 5.6, the ** operator was tokenized as two
-                T_MULTIPLY tokens in a row. So look for and combine
-                these tokens in earlier versions.
-            */
-
-            if ($tokenIsArray === false
-                && $token[0] === '*'
-                && isset($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)] === '*'
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_POW;
-                $newToken['type']    = 'T_POW';
-                $newToken['content'] = '**';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr++;
-                continue;
-            }
-
-            /*
-                Before PHP 5.6, the **= operator was tokenized as
-                T_MULTIPLY followed by T_MUL_EQUAL. So look for and combine
-                these tokens in earlier versions.
-            */
-
-            if ($tokenIsArray === false
-                && $token[0] === '*'
-                && isset($tokens[($stackPtr + 1)]) === true
-                && is_array($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][1] === '*='
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_POW_EQUAL;
-                $newToken['type']    = 'T_POW_EQUAL';
-                $newToken['content'] = '**=';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr++;
-                continue;
-            }
-
-            /*
-                Before PHP 7, the ??= operator was tokenized as
-                T_INLINE_THEN, T_INLINE_THEN, T_EQUAL.
-                Between PHP 7.0 and 7.3, the ??= operator was tokenized as
-                T_COALESCE, T_EQUAL.
-                So look for and combine these tokens in earlier versions.
-            */
-
-            if (($tokenIsArray === false
-                && $token[0] === '?'
-                && isset($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === '?'
-                && isset($tokens[($stackPtr + 2)]) === true
-                && $tokens[($stackPtr + 2)][0] === '=')
-                || ($tokenIsArray === true
-                && $token[0] === T_COALESCE
-                && isset($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === '=')
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_COALESCE_EQUAL;
-                $newToken['type']    = 'T_COALESCE_EQUAL';
-                $newToken['content'] = '??=';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr++;
-
-                if ($tokenIsArray === false) {
-                    // Pre PHP 7.
-                    $stackPtr++;
-                }
-
-                continue;
-            }
-
-            /*
-                Before PHP 7, the ?? operator was tokenized as
-                T_INLINE_THEN followed by T_INLINE_THEN.
-                So look for and combine these tokens in earlier versions.
-            */
-
-            if ($tokenIsArray === false
-                && $token[0] === '?'
-                && isset($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === '?'
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_COALESCE;
-                $newToken['type']    = 'T_COALESCE';
-                $newToken['content'] = '??';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr++;
-                continue;
-            }
-
-            /*
-                Before PHP 8, the ?-> operator was tokenized as
-                T_INLINE_THEN followed by T_OBJECT_OPERATOR.
-                So look for and combine these tokens in earlier versions.
-            */
-
-            if ($tokenIsArray === false
-                && $token[0] === '?'
-                && isset($tokens[($stackPtr + 1)]) === true
-                && is_array($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === T_OBJECT_OPERATOR
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_NULLSAFE_OBJECT_OPERATOR;
-                $newToken['type']    = 'T_NULLSAFE_OBJECT_OPERATOR';
-                $newToken['content'] = '?->';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr++;
-                continue;
-            }
-
-            /*
-                Before PHP 7.4, underscores inside T_LNUMBER and T_DNUMBER
-                tokens split the token with a T_STRING. So look for
-                and change these tokens in earlier versions.
-            */
-
-            if (PHP_VERSION_ID < 70400
-                && ($tokenIsArray === true
-                && ($token[0] === T_LNUMBER
-                || $token[0] === T_DNUMBER)
-                && isset($tokens[($stackPtr + 1)]) === true
-                && is_array($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === T_STRING
-                && $tokens[($stackPtr + 1)][1][0] === '_')
-            ) {
-                $newContent = $token[1];
-                $newType    = $token[0];
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    if (is_array($tokens[$i]) === false) {
-                        break;
-                    }
-
-                    if ($tokens[$i][0] === T_LNUMBER
-                        || $tokens[$i][0] === T_DNUMBER
-                    ) {
-                        $newContent .= $tokens[$i][1];
-                        continue;
-                    }
-
-                    if ($tokens[$i][0] === T_STRING
-                        && $tokens[$i][1][0] === '_'
-                        && ((strpos($newContent, '0x') === 0
-                        && preg_match('`^((?<!\.)_[0-9A-F][0-9A-F\.]*)+$`iD', $tokens[$i][1]) === 1)
-                        || (strpos($newContent, '0x') !== 0
-                        && substr($newContent, -1) !== '.'
-                        && substr(strtolower($newContent), -1) !== 'e'
-                        && preg_match('`^(?:(?<![\.e])_[0-9][0-9e\.]*)+$`iD', $tokens[$i][1]) === 1))
-                    ) {
-                        $newContent .= $tokens[$i][1];
-
-                        // Support floats.
-                        if (substr(strtolower($tokens[$i][1]), -1) === 'e'
-                            && ($tokens[($i + 1)] === '-'
-                            || $tokens[($i + 1)] === '+')
-                        ) {
-                            $newContent .= $tokens[($i + 1)];
-                            $i++;
-                        }
-
-                        continue;
-                    }//end if
-
-                    break;
-                }//end for
-
-                if ($newType === T_LNUMBER
-                    && ((stripos($newContent, '0x') === 0 && hexdec(str_replace('_', '', $newContent)) > PHP_INT_MAX)
-                    || (stripos($newContent, '0b') === 0 && bindec(str_replace('_', '', $newContent)) > PHP_INT_MAX)
-                    || (stripos($newContent, '0o') === 0 && octdec(str_replace('_', '', $newContent)) > PHP_INT_MAX)
-                    || (stripos($newContent, '0x') !== 0
-                    && (stripos($newContent, 'e') !== false || strpos($newContent, '.') !== false))
-                    || (strpos($newContent, '0') === 0 && stripos($newContent, '0x') !== 0
-                    && stripos($newContent, '0b') !== 0 && octdec(str_replace('_', '', $newContent)) > PHP_INT_MAX)
-                    || (strpos($newContent, '0') !== 0 && str_replace('_', '', $newContent) > PHP_INT_MAX))
-                ) {
-                    $newType = T_DNUMBER;
-                }
-
-                $newToken            = [];
-                $newToken['code']    = $newType;
-                $newToken['type']    = Tokens::tokenName($newType);
-                $newToken['content'] = $newContent;
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr = ($i - 1);
-                continue;
-            }//end if
-
-            /*
-                Backfill the T_MATCH token for PHP versions < 8.0 and
-                do initial correction for non-match expression T_MATCH tokens
-                to T_STRING for PHP >= 8.0.
-                A final check for non-match expression T_MATCH tokens is done
-                in PHP::processAdditional().
-            */
-
-            if ($tokenIsArray === true
-                && (($token[0] === T_STRING
-                && strtolower($token[1]) === 'match')
-                || $token[0] === T_MATCH)
-            ) {
-                $isMatch = false;
-                for ($x = ($stackPtr + 1); $x < $numTokens; $x++) {
-                    if (isset($tokens[$x][0], Tokens::$emptyTokens[$tokens[$x][0]]) === true) {
-                        continue;
-                    }
-
-                    if ($tokens[$x] !== '(') {
-                        // This is not a match expression.
-                        break;
-                    }
-
-                    if (isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === true) {
-                        // Also not a match expression.
-                        break;
-                    }
-
-                    $isMatch = true;
-                    break;
-                }//end for
-
-                if ($isMatch === true && $token[0] === T_STRING) {
-                    $newToken            = [];
-                    $newToken['code']    = T_MATCH;
-                    $newToken['type']    = 'T_MATCH';
-                    $newToken['content'] = $token[1];
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from T_STRING to T_MATCH".PHP_EOL;
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                    continue;
-                } else if ($isMatch === false && $token[0] === T_MATCH) {
-                    // PHP 8.0, match keyword, but not a match expression.
-                    $newToken            = [];
-                    $newToken['code']    = T_STRING;
-                    $newToken['type']    = 'T_STRING';
-                    $newToken['content'] = $token[1];
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from T_MATCH to T_STRING".PHP_EOL;
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                    continue;
-                }//end if
-            }//end if
-
-            /*
-                Retokenize the T_DEFAULT in match control structures as T_MATCH_DEFAULT
-                to prevent scope being set and the scope for switch default statements
-                breaking.
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_DEFAULT
-                && isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === false
-            ) {
-                for ($x = ($stackPtr + 1); $x < $numTokens; $x++) {
-                    if ($tokens[$x] === ',') {
-                        // Skip over potential trailing comma (supported in PHP).
-                        continue;
-                    }
-
-                    if (is_array($tokens[$x]) === false
-                        || isset(Tokens::$emptyTokens[$tokens[$x][0]]) === false
-                    ) {
-                        // Non-empty, non-comma content.
-                        break;
-                    }
-                }
-
-                if (isset($tokens[$x]) === true
-                    && is_array($tokens[$x]) === true
-                    && $tokens[$x][0] === T_DOUBLE_ARROW
-                ) {
-                    // Modify the original token stack for the double arrow so that
-                    // future checks can disregard the double arrow token more easily.
-                    // For match expression "case" statements, this is handled
-                    // in PHP::processAdditional().
-                    $tokens[$x][0] = T_MATCH_ARROW;
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $x changed from T_DOUBLE_ARROW to T_MATCH_ARROW".PHP_EOL;
-                    }
-
-                    $newToken            = [];
-                    $newToken['code']    = T_MATCH_DEFAULT;
-                    $newToken['type']    = 'T_MATCH_DEFAULT';
-                    $newToken['content'] = $token[1];
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from T_DEFAULT to T_MATCH_DEFAULT".PHP_EOL;
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                    continue;
-                }//end if
-            }//end if
-
-            /*
-                Convert ? to T_NULLABLE OR T_INLINE_THEN
-            */
-
-            if ($tokenIsArray === false && $token[0] === '?') {
-                $newToken            = [];
-                $newToken['content'] = '?';
-
-                // For typed constants, we only need to check the token before the ? to be sure.
-                if ($finalTokens[$lastNotEmptyToken]['code'] === T_CONST) {
-                    $newToken['code'] = T_NULLABLE;
-                    $newToken['type'] = 'T_NULLABLE';
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from ? to T_NULLABLE".PHP_EOL;
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                    continue;
-                }
-
-                /*
-                 * Check if the next non-empty token is one of the tokens which can be used
-                 * in type declarations. If not, it's definitely a ternary.
-                 * At this point, the only token types which need to be taken into consideration
-                 * as potential type declarations are identifier names, T_ARRAY, T_CALLABLE and T_NS_SEPARATOR.
-                 */
-
-                $lastRelevantNonEmpty = null;
-
-                for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                    if (is_array($tokens[$i]) === true) {
-                        $tokenType = $tokens[$i][0];
-                    } else {
-                        $tokenType = $tokens[$i];
-                    }
-
-                    if (isset(Tokens::$emptyTokens[$tokenType]) === true) {
-                        continue;
-                    }
-
-                    if ($tokenType === T_STRING
-                        || $tokenType === T_NAME_FULLY_QUALIFIED
-                        || $tokenType === T_NAME_RELATIVE
-                        || $tokenType === T_NAME_QUALIFIED
-                        || $tokenType === T_ARRAY
-                        || $tokenType === T_NAMESPACE
-                        || $tokenType === T_NS_SEPARATOR
-                    ) {
-                        $lastRelevantNonEmpty = $tokenType;
-                        continue;
-                    }
-
-                    if (($tokenType !== T_CALLABLE
-                        && isset($lastRelevantNonEmpty) === false)
-                        || ($lastRelevantNonEmpty === T_ARRAY
-                        && $tokenType === '(')
-                        || (($lastRelevantNonEmpty === T_STRING
-                        || $lastRelevantNonEmpty === T_NAME_FULLY_QUALIFIED
-                        || $lastRelevantNonEmpty === T_NAME_RELATIVE
-                        || $lastRelevantNonEmpty === T_NAME_QUALIFIED)
-                        && ($tokenType === T_DOUBLE_COLON
-                        || $tokenType === '('
-                        || $tokenType === ':'))
-                    ) {
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            echo "\t\t* token $stackPtr changed from ? to T_INLINE_THEN".PHP_EOL;
-                        }
-
-                        $newToken['code'] = T_INLINE_THEN;
-                        $newToken['type'] = 'T_INLINE_THEN';
-
-                        $insideInlineIf[] = $stackPtr;
-
-                        $finalTokens[$newStackPtr] = $newToken;
-                        $newStackPtr++;
-                        continue 2;
-                    }
-
-                    break;
-                }//end for
-
-                /*
-                 * This can still be a nullable type or a ternary.
-                 * Do additional checking.
-                 */
-
-                $prevNonEmpty     = null;
-                $lastSeenNonEmpty = null;
-
-                for ($i = ($stackPtr - 1); $i >= 0; $i--) {
-                    if (is_array($tokens[$i]) === true) {
-                        $tokenType = $tokens[$i][0];
-                    } else {
-                        $tokenType = $tokens[$i];
-                    }
-
-                    if ($tokenType === T_STATIC
-                        && ($lastSeenNonEmpty === T_DOUBLE_COLON
-                        || $lastSeenNonEmpty === '(')
-                    ) {
-                        $lastSeenNonEmpty = $tokenType;
-                        continue;
-                    }
-
-                    if ($prevNonEmpty === null
-                        && isset(Tokens::$emptyTokens[$tokenType]) === false
-                    ) {
-                        // Found the previous non-empty token.
-                        if ($tokenType === ':' || $tokenType === ',' || $tokenType === T_ATTRIBUTE_END) {
-                            $newToken['code'] = T_NULLABLE;
-                            $newToken['type'] = 'T_NULLABLE';
-
-                            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                echo "\t\t* token $stackPtr changed from ? to T_NULLABLE".PHP_EOL;
-                            }
-
-                            break;
-                        }
-
-                        $prevNonEmpty = $tokenType;
-                    }
-
-                    if ($tokenType === T_FUNCTION
-                        || $tokenType === T_FN
-                        || isset(Tokens::$methodPrefixes[$tokenType]) === true
-                        || $tokenType === T_VAR
-                    ) {
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            echo "\t\t* token $stackPtr changed from ? to T_NULLABLE".PHP_EOL;
-                        }
-
-                        $newToken['code'] = T_NULLABLE;
-                        $newToken['type'] = 'T_NULLABLE';
-                        break;
-                    } else if (in_array($tokenType, [T_DOUBLE_ARROW, T_OPEN_TAG, T_OPEN_TAG_WITH_ECHO, '=', '{', ';'], true) === true) {
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            echo "\t\t* token $stackPtr changed from ? to T_INLINE_THEN".PHP_EOL;
-                        }
-
-                        $newToken['code'] = T_INLINE_THEN;
-                        $newToken['type'] = 'T_INLINE_THEN';
-
-                        $insideInlineIf[] = $stackPtr;
-                        break;
-                    }
-
-                    if (isset(Tokens::$emptyTokens[$tokenType]) === false) {
-                        $lastSeenNonEmpty = $tokenType;
-                    }
-                }//end for
-
-                $finalTokens[$newStackPtr] = $newToken;
-                $newStackPtr++;
-                continue;
-            }//end if
-
-            /*
-                Tokens after a double colon may look like scope openers,
-                such as when writing code like Foo::NAMESPACE, but they are
-                only ever variables or strings.
-            */
-
-            if ($stackPtr > 1
-                && (is_array($tokens[($stackPtr - 1)]) === true
-                && $tokens[($stackPtr - 1)][0] === T_PAAMAYIM_NEKUDOTAYIM)
-                && $tokenIsArray === true
-                && $token[0] !== T_STRING
-                && $token[0] !== T_VARIABLE
-                && $token[0] !== T_DOLLAR
-                && isset(Tokens::$emptyTokens[$token[0]]) === false
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_STRING;
-                $newToken['type']    = 'T_STRING';
-                $newToken['content'] = $token[1];
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                continue;
-            }
-
-            /*
-                Backfill the T_FN token for PHP versions < 7.4.
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_STRING
-                && strtolower($token[1]) === 'fn'
-            ) {
-                // Modify the original token stack so that
-                // future checks (like looking for T_NULLABLE) can
-                // detect the T_FN token more easily.
-                $tokens[$stackPtr][0] = T_FN;
-                $token[0] = T_FN;
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\t* token $stackPtr changed from T_STRING to T_FN".PHP_EOL;
-                }
-            }
-
-            /*
-                This is a special condition for T_ARRAY tokens used for
-                function return types. We want to keep the parenthesis map clean,
-                so let's tag these tokens as T_STRING.
-            */
-
-            if ($tokenIsArray === true
-                && ($token[0] === T_FUNCTION
-                || $token[0] === T_FN)
-                && $finalTokens[$lastNotEmptyToken]['code'] !== T_USE
-            ) {
-                // Go looking for the colon to start the return type hint.
-                // Start by finding the closing parenthesis of the function.
-                $parenthesisStack  = [];
-                $parenthesisCloser = false;
-                for ($x = ($stackPtr + 1); $x < $numTokens; $x++) {
-                    if (is_array($tokens[$x]) === false && $tokens[$x] === '(') {
-                        $parenthesisStack[] = $x;
-                    } else if (is_array($tokens[$x]) === false && $tokens[$x] === ')') {
-                        array_pop($parenthesisStack);
-                        if (empty($parenthesisStack) === true) {
-                            $parenthesisCloser = $x;
-                            break;
-                        }
-                    }
-                }
-
-                if ($parenthesisCloser !== false) {
-                    for ($x = ($parenthesisCloser + 1); $x < $numTokens; $x++) {
-                        if (is_array($tokens[$x]) === false
-                            || isset(Tokens::$emptyTokens[$tokens[$x][0]]) === false
-                        ) {
-                            // Non-empty content.
-                            if (is_array($tokens[$x]) === true && $tokens[$x][0] === T_USE) {
-                                // Found a use statements, so search ahead for the closing parenthesis.
-                                for ($x += 1; $x < $numTokens; $x++) {
-                                    if (is_array($tokens[$x]) === false && $tokens[$x] === ')') {
-                                        continue(2);
-                                    }
-                                }
-                            }
-
-                            break;
-                        }
-                    }
-
-                    if (isset($tokens[$x]) === true
-                        && is_array($tokens[$x]) === false
-                        && $tokens[$x] === ':'
-                    ) {
-                        // Find the start of the return type.
-                        for ($x += 1; $x < $numTokens; $x++) {
-                            if (is_array($tokens[$x]) === true
-                                && isset(Tokens::$emptyTokens[$tokens[$x][0]]) === true
-                            ) {
-                                // Whitespace or comments before the return type.
-                                continue;
-                            }
-
-                            if (is_array($tokens[$x]) === false && $tokens[$x] === '?') {
-                                // Found a nullable operator, so skip it.
-                                // But also convert the token to save the tokenizer
-                                // a bit of time later on.
-                                $tokens[$x] = [
-                                    T_NULLABLE,
-                                    '?',
-                                ];
-
-                                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                    echo "\t\t* token $x changed from ? to T_NULLABLE".PHP_EOL;
-                                }
-
-                                continue;
-                            }
-
-                            break;
-                        }//end for
-                    }//end if
-                }//end if
-            }//end if
-
-            /*
-                Before PHP 7, the <=> operator was tokenized as
-                T_IS_SMALLER_OR_EQUAL followed by T_GREATER_THAN.
-                So look for and combine these tokens in earlier versions.
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_IS_SMALLER_OR_EQUAL
-                && isset($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)][0] === '>'
-            ) {
-                $newToken            = [];
-                $newToken['code']    = T_SPACESHIP;
-                $newToken['type']    = 'T_SPACESHIP';
-                $newToken['content'] = '<=>';
-                $finalTokens[$newStackPtr] = $newToken;
-
-                $newStackPtr++;
-                $stackPtr++;
-                continue;
-            }
-
-            /*
-                PHP doesn't assign a token to goto labels, so we have to.
-                These are just string tokens with a single colon after them. Double
-                colons are already tokenized and so don't interfere with this check.
-                But we do have to account for CASE statements, that look just like
-                goto labels.
-            */
-
-            if ($tokenIsArray === true
-                && $token[0] === T_STRING
-                && isset($tokens[($stackPtr + 1)]) === true
-                && $tokens[($stackPtr + 1)] === ':'
-                && (is_array($tokens[($stackPtr - 1)]) === false
-                || $tokens[($stackPtr - 1)][0] !== T_PAAMAYIM_NEKUDOTAYIM)
-            ) {
-                $stopTokens = [
-                    T_CASE               => true,
-                    T_SEMICOLON          => true,
-                    T_OPEN_TAG           => true,
-                    T_OPEN_CURLY_BRACKET => true,
-                    T_INLINE_THEN        => true,
-                    T_ENUM               => true,
-                ];
-
-                for ($x = ($newStackPtr - 1); $x > 0; $x--) {
-                    if (isset($stopTokens[$finalTokens[$x]['code']]) === true) {
-                        break;
-                    }
-                }
-
-                if ($finalTokens[$x]['code'] !== T_CASE
-                    && $finalTokens[$x]['code'] !== T_INLINE_THEN
-                    && $finalTokens[$x]['code'] !== T_ENUM
-                ) {
-                    $finalTokens[$newStackPtr] = [
-                        'content' => $token[1].':',
-                        'code'    => T_GOTO_LABEL,
-                        'type'    => 'T_GOTO_LABEL',
-                    ];
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $stackPtr changed from T_STRING to T_GOTO_LABEL".PHP_EOL;
-                        echo "\t\t* skipping T_COLON token ".($stackPtr + 1).PHP_EOL;
-                    }
-
-                    $newStackPtr++;
-                    $stackPtr++;
-                    continue;
-                }
-            }//end if
-
-            /*
-                If this token has newlines in its content, split each line up
-                and create a new token for each line. We do this so it's easier
-                to ascertain where errors occur on a line.
-                Note that $token[1] is the token's content.
-            */
-
-            if ($tokenIsArray === true && strpos($token[1], $this->eolChar) !== false) {
-                $tokenLines = explode($this->eolChar, $token[1]);
-                $numLines   = count($tokenLines);
-                $newToken   = [
-                    'type'    => Tokens::tokenName($token[0]),
-                    'code'    => $token[0],
-                    'content' => '',
-                ];
-
-                for ($i = 0; $i < $numLines; $i++) {
-                    $newToken['content'] = $tokenLines[$i];
-                    if ($i === ($numLines - 1)) {
-                        if ($tokenLines[$i] === '') {
-                            break;
-                        }
-                    } else {
-                        $newToken['content'] .= $this->eolChar;
-                    }
-
-                    $finalTokens[$newStackPtr] = $newToken;
-                    $newStackPtr++;
-                }
-            } else {
-                // Some T_STRING tokens should remain that way due to their context.
-                if ($tokenIsArray === true && $token[0] === T_STRING) {
-                    $preserveTstring = false;
-
-                    // True/false/parent/self/static in typed constants should be fixed to their own token,
-                    // but the constant name should not be.
-                    if ((isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === true
-                        && $finalTokens[$lastNotEmptyToken]['code'] === T_CONST)
-                        || $insideConstDeclaration === true
-                    ) {
-                        // Find the next non-empty token.
-                        for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                            if (is_array($tokens[$i]) === true
-                                && isset(Tokens::$emptyTokens[$tokens[$i][0]]) === true
-                            ) {
-                                continue;
-                            }
-
-                            break;
-                        }
-
-                        if ($tokens[$i] === '=') {
-                            $preserveTstring        = true;
-                            $insideConstDeclaration = false;
-                        }
-                    } else if (isset($this->tstringContexts[$finalTokens[$lastNotEmptyToken]['code']]) === true
-                        && $finalTokens[$lastNotEmptyToken]['code'] !== T_CONST
-                    ) {
-                        $preserveTstring = true;
-
-                        // Special case for syntax like: return new self/new parent
-                        // where self/parent should not be a string.
-                        $tokenContentLower = strtolower($token[1]);
-                        if ($finalTokens[$lastNotEmptyToken]['code'] === T_NEW
-                            && ($tokenContentLower === 'self' || $tokenContentLower === 'parent')
-                        ) {
-                            $preserveTstring = false;
-                        }
-                    } else if ($finalTokens[$lastNotEmptyToken]['content'] === '&') {
-                        // Function names for functions declared to return by reference.
-                        for ($i = ($lastNotEmptyToken - 1); $i >= 0; $i--) {
-                            if (isset(Tokens::$emptyTokens[$finalTokens[$i]['code']]) === true) {
-                                continue;
-                            }
-
-                            if ($finalTokens[$i]['code'] === T_FUNCTION) {
-                                $preserveTstring = true;
-                            }
-
-                            break;
-                        }
-                    } else {
-                        // Keywords with special PHPCS token when used as a function call.
-                        for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                            if (is_array($tokens[$i]) === true
-                                && isset(Tokens::$emptyTokens[$tokens[$i][0]]) === true
-                            ) {
-                                continue;
-                            }
-
-                            if ($tokens[$i][0] === '(') {
-                                $preserveTstring = true;
-                            }
-
-                            break;
-                        }
-                    }//end if
-
-                    if ($preserveTstring === true) {
-                        $finalTokens[$newStackPtr] = [
-                            'code'    => T_STRING,
-                            'type'    => 'T_STRING',
-                            'content' => $token[1],
-                        ];
-
-                        $newStackPtr++;
-                        continue;
-                    }
-                }//end if
-
-                $newToken = null;
-                if ($tokenIsArray === false) {
-                    if (isset(self::$resolveTokenCache[$token[0]]) === true) {
-                        $newToken = self::$resolveTokenCache[$token[0]];
-                    }
-                } else {
-                    $cacheKey = null;
-                    if ($token[0] === T_STRING) {
-                        $cacheKey = strtolower($token[1]);
-                    } else if ($token[0] !== T_CURLY_OPEN) {
-                        $cacheKey = $token[0];
-                    }
-
-                    if ($cacheKey !== null && isset(self::$resolveTokenCache[$cacheKey]) === true) {
-                        $newToken            = self::$resolveTokenCache[$cacheKey];
-                        $newToken['content'] = $token[1];
-                    }
-                }
-
-                if ($newToken === null) {
-                    $newToken = self::standardiseToken($token);
-                }
-
-                // Convert colons that are actually the ELSE component of an
-                // inline IF statement.
-                if (empty($insideInlineIf) === false && $newToken['code'] === T_COLON) {
-                    $isInlineIf = true;
-
-                    // Make sure this isn't a named parameter label.
-                    // Get the previous non-empty token.
-                    for ($i = ($stackPtr - 1); $i > 0; $i--) {
-                        if (is_array($tokens[$i]) === false
-                            || isset(Tokens::$emptyTokens[$tokens[$i][0]]) === false
-                        ) {
-                            break;
-                        }
-                    }
-
-                    if ($tokens[$i][0] === T_PARAM_NAME) {
-                        $isInlineIf = false;
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            echo "\t\t* token is parameter label, not T_INLINE_ELSE".PHP_EOL;
-                        }
-                    }
-
-                    if ($isInlineIf === true) {
-                        // Make sure this isn't a return type separator.
-                        for ($i = ($stackPtr - 1); $i > 0; $i--) {
-                            if (is_array($tokens[$i]) === false
-                                || ($tokens[$i][0] !== T_DOC_COMMENT
-                                && $tokens[$i][0] !== T_COMMENT
-                                && $tokens[$i][0] !== T_WHITESPACE)
-                            ) {
-                                break;
-                            }
-                        }
-
-                        if ($tokens[$i] === ')') {
-                            $parenCount = 1;
-                            for ($i--; $i > 0; $i--) {
-                                if ($tokens[$i] === '(') {
-                                    $parenCount--;
-                                    if ($parenCount === 0) {
-                                        break;
-                                    }
-                                } else if ($tokens[$i] === ')') {
-                                    $parenCount++;
-                                }
-                            }
-
-                            // We've found the open parenthesis, so if the previous
-                            // non-empty token is FUNCTION or USE, this is a return type.
-                            // Note that we need to skip T_STRING tokens here as these
-                            // can be function names.
-                            for ($i--; $i > 0; $i--) {
-                                if (is_array($tokens[$i]) === false
-                                    || ($tokens[$i][0] !== T_DOC_COMMENT
-                                    && $tokens[$i][0] !== T_COMMENT
-                                    && $tokens[$i][0] !== T_WHITESPACE
-                                    && $tokens[$i][0] !== T_STRING)
-                                ) {
-                                    break;
-                                }
-                            }
-
-                            if ($tokens[$i][0] === T_FUNCTION || $tokens[$i][0] === T_FN || $tokens[$i][0] === T_USE) {
-                                $isInlineIf = false;
-                                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                    echo "\t\t* token is return type, not T_INLINE_ELSE".PHP_EOL;
-                                }
-                            }
-                        }//end if
-                    }//end if
-
-                    // Check to see if this is a CASE or DEFAULT opener.
-                    if ($isInlineIf === true) {
-                        $inlineIfToken = $insideInlineIf[(count($insideInlineIf) - 1)];
-                        for ($i = $stackPtr; $i > $inlineIfToken; $i--) {
-                            if (is_array($tokens[$i]) === true
-                                && ($tokens[$i][0] === T_CASE
-                                || $tokens[$i][0] === T_DEFAULT)
-                            ) {
-                                $isInlineIf = false;
-                                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                    echo "\t\t* token is T_CASE or T_DEFAULT opener, not T_INLINE_ELSE".PHP_EOL;
-                                }
-
-                                break;
-                            }
-
-                            if (is_array($tokens[$i]) === false
-                                && ($tokens[$i] === ';'
-                                || $tokens[$i] === '{'
-                                || $tokens[$i] === '}')
-                            ) {
-                                break;
-                            }
-                        }//end for
-                    }//end if
-
-                    if ($isInlineIf === true) {
-                        array_pop($insideInlineIf);
-                        $newToken['code'] = T_INLINE_ELSE;
-                        $newToken['type'] = 'T_INLINE_ELSE';
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            echo "\t\t* token changed from T_COLON to T_INLINE_ELSE".PHP_EOL;
-                        }
-                    }
-                }//end if
-
-                // This is a special condition for T_ARRAY tokens used for anything else
-                // but array declarations, like type hinting function arguments as
-                // being arrays.
-                // We want to keep the parenthesis map clean, so let's tag these tokens as
-                // T_STRING.
-                if ($newToken['code'] === T_ARRAY) {
-                    for ($i = ($stackPtr + 1); $i < $numTokens; $i++) {
-                        if (is_array($tokens[$i]) === false
-                            || isset(Tokens::$emptyTokens[$tokens[$i][0]]) === false
-                        ) {
-                            // Non-empty content.
-                            break;
-                        }
-                    }
-
-                    if ($i !== $numTokens && $tokens[$i] !== '(') {
-                        $newToken['code'] = T_STRING;
-                        $newToken['type'] = 'T_STRING';
-                    }
-                }
-
-                // This is a special case when checking PHP 5.5+ code in PHP < 5.5
-                // where "finally" should be T_FINALLY instead of T_STRING.
-                if ($newToken['code'] === T_STRING
-                    && strtolower($newToken['content']) === 'finally'
-                    && $finalTokens[$lastNotEmptyToken]['code'] === T_CLOSE_CURLY_BRACKET
-                ) {
-                    $newToken['code'] = T_FINALLY;
-                    $newToken['type'] = 'T_FINALLY';
-                }
-
-                // This is a special case for PHP 5.6 use function and use const
-                // where "function" and "const" should be T_STRING instead of T_FUNCTION
-                // and T_CONST.
-                if (($newToken['code'] === T_FUNCTION
-                    || $newToken['code'] === T_CONST)
-                    && ($finalTokens[$lastNotEmptyToken]['code'] === T_USE || $insideUseGroup === true)
-                ) {
-                    $newToken['code'] = T_STRING;
-                    $newToken['type'] = 'T_STRING';
-                }
-
-                // This is a special case for use groups in PHP 7+ where leaving
-                // the curly braces as their normal tokens would confuse
-                // the scope map and sniffs.
-                if ($newToken['code'] === T_OPEN_CURLY_BRACKET
-                    && $finalTokens[$lastNotEmptyToken]['code'] === T_NS_SEPARATOR
-                ) {
-                    $newToken['code'] = T_OPEN_USE_GROUP;
-                    $newToken['type'] = 'T_OPEN_USE_GROUP';
-                    $insideUseGroup   = true;
-                }
-
-                if ($insideUseGroup === true && $newToken['code'] === T_CLOSE_CURLY_BRACKET) {
-                    $newToken['code'] = T_CLOSE_USE_GROUP;
-                    $newToken['type'] = 'T_CLOSE_USE_GROUP';
-                    $insideUseGroup   = false;
-                }
-
-                $finalTokens[$newStackPtr] = $newToken;
-                $newStackPtr++;
-            }//end if
-        }//end for
-
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            echo "\t*** END PHP TOKENIZING ***".PHP_EOL;
-        }
-
-        return $finalTokens;
-
-    }//end tokenize()
-
-
-    /**
-     * Performs additional processing after main tokenizing.
-     *
-     * This additional processing checks for CASE statements that are using curly
-     * braces for scope openers and closers. It also turns some T_FUNCTION tokens
-     * into T_CLOSURE when they are not standard function definitions. It also
-     * detects short array syntax and converts those square brackets into new tokens.
-     * It also corrects some usage of the static and class keywords. It also
-     * assigns tokens to function return types.
-     *
-     * @return void
-     */
-    protected function processAdditional()
-    {
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            echo "\t*** START ADDITIONAL PHP PROCESSING ***".PHP_EOL;
-        }
-
-        $this->createAttributesNestingMap();
-
-        $numTokens         = count($this->tokens);
-        $lastSeenTypeToken = $numTokens;
-
-        for ($i = ($numTokens - 1); $i >= 0; $i--) {
-            // Check for any unset scope conditions due to alternate IF/ENDIF syntax.
-            if (isset($this->tokens[$i]['scope_opener']) === true
-                && isset($this->tokens[$i]['scope_condition']) === false
-            ) {
-                $this->tokens[$i]['scope_condition'] = $this->tokens[$this->tokens[$i]['scope_opener']]['scope_condition'];
-            }
-
-            if ($this->tokens[$i]['code'] === T_FUNCTION) {
-                /*
-                    Detect functions that are actually closures and
-                    assign them a different token.
-                */
-
-                if (isset($this->tokens[$i]['scope_opener']) === true) {
-                    for ($x = ($i + 1); $x < $numTokens; $x++) {
-                        if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false
-                            && $this->tokens[$x]['code'] !== T_BITWISE_AND
-                        ) {
-                            break;
-                        }
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS) {
-                        $this->tokens[$i]['code'] = T_CLOSURE;
-                        $this->tokens[$i]['type'] = 'T_CLOSURE';
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$i]['line'];
-                            echo "\t* token $i on line $line changed from T_FUNCTION to T_CLOSURE".PHP_EOL;
-                        }
-
-                        for ($x = ($this->tokens[$i]['scope_opener'] + 1); $x < $this->tokens[$i]['scope_closer']; $x++) {
-                            if (isset($this->tokens[$x]['conditions'][$i]) === false) {
-                                continue;
-                            }
-
-                            $this->tokens[$x]['conditions'][$i] = T_CLOSURE;
-                            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                $type = $this->tokens[$x]['type'];
-                                echo "\t\t* cleaned $x ($type) *".PHP_EOL;
-                            }
-                        }
-                    }
-                }//end if
-
-                continue;
-            } else if ($this->tokens[$i]['code'] === T_CLASS && isset($this->tokens[$i]['scope_opener']) === true) {
-                /*
-                    Detect anonymous classes and assign them a different token.
-                */
-
-                for ($x = ($i + 1); $x < $numTokens; $x++) {
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) {
-                        break;
-                    }
-                }
-
-                if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS
-                    || $this->tokens[$x]['code'] === T_OPEN_CURLY_BRACKET
-                    || $this->tokens[$x]['code'] === T_EXTENDS
-                    || $this->tokens[$x]['code'] === T_IMPLEMENTS
-                ) {
-                    $this->tokens[$i]['code'] = T_ANON_CLASS;
-                    $this->tokens[$i]['type'] = 'T_ANON_CLASS';
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $line = $this->tokens[$i]['line'];
-                        echo "\t* token $i on line $line changed from T_CLASS to T_ANON_CLASS".PHP_EOL;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS
-                        && isset($this->tokens[$x]['parenthesis_closer']) === true
-                    ) {
-                        $closer = $this->tokens[$x]['parenthesis_closer'];
-
-                        $this->tokens[$i]['parenthesis_opener']     = $x;
-                        $this->tokens[$i]['parenthesis_closer']     = $closer;
-                        $this->tokens[$i]['parenthesis_owner']      = $i;
-                        $this->tokens[$x]['parenthesis_owner']      = $i;
-                        $this->tokens[$closer]['parenthesis_owner'] = $i;
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$i]['line'];
-                            echo "\t\t* added parenthesis keys to T_ANON_CLASS token $i on line $line".PHP_EOL;
-                        }
-                    }
-
-                    for ($x = ($this->tokens[$i]['scope_opener'] + 1); $x < $this->tokens[$i]['scope_closer']; $x++) {
-                        if (isset($this->tokens[$x]['conditions'][$i]) === false) {
-                            continue;
-                        }
-
-                        $this->tokens[$x]['conditions'][$i] = T_ANON_CLASS;
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $type = $this->tokens[$x]['type'];
-                            echo "\t\t* cleaned $x ($type) *".PHP_EOL;
-                        }
-                    }
-                }//end if
-
-                continue;
-            } else if ($this->tokens[$i]['code'] === T_FN && isset($this->tokens[($i + 1)]) === true) {
-                // Possible arrow function.
-                for ($x = ($i + 1); $x < $numTokens; $x++) {
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false
-                        && $this->tokens[$x]['code'] !== T_BITWISE_AND
-                    ) {
-                        // Non-whitespace content.
-                        break;
-                    }
-                }
-
-                if (isset($this->tokens[$x]) === true
-                    && $this->tokens[$x]['code'] === T_OPEN_PARENTHESIS
-                    && isset($this->tokens[$x]['parenthesis_closer']) === true
-                ) {
-                    $ignore  = Tokens::$emptyTokens;
-                    $ignore += [
-                        T_ARRAY                  => T_ARRAY,
-                        T_CALLABLE               => T_CALLABLE,
-                        T_COLON                  => T_COLON,
-                        T_NAMESPACE              => T_NAMESPACE,
-                        T_NS_SEPARATOR           => T_NS_SEPARATOR,
-                        T_NULL                   => T_NULL,
-                        T_TRUE                   => T_TRUE,
-                        T_FALSE                  => T_FALSE,
-                        T_NULLABLE               => T_NULLABLE,
-                        T_PARENT                 => T_PARENT,
-                        T_SELF                   => T_SELF,
-                        T_STATIC                 => T_STATIC,
-                        T_STRING                 => T_STRING,
-                        T_TYPE_UNION             => T_TYPE_UNION,
-                        T_TYPE_INTERSECTION      => T_TYPE_INTERSECTION,
-                        T_TYPE_OPEN_PARENTHESIS  => T_TYPE_OPEN_PARENTHESIS,
-                        T_TYPE_CLOSE_PARENTHESIS => T_TYPE_CLOSE_PARENTHESIS,
-                    ];
-
-                    $closer = $this->tokens[$x]['parenthesis_closer'];
-                    for ($arrow = ($closer + 1); $arrow < $numTokens; $arrow++) {
-                        if (isset($ignore[$this->tokens[$arrow]['code']]) === false) {
-                            break;
-                        }
-                    }
-
-                    if ($this->tokens[$arrow]['code'] === T_DOUBLE_ARROW) {
-                        $endTokens = [
-                            T_COLON                => true,
-                            T_COMMA                => true,
-                            T_SEMICOLON            => true,
-                            T_CLOSE_PARENTHESIS    => true,
-                            T_CLOSE_SQUARE_BRACKET => true,
-                            T_CLOSE_CURLY_BRACKET  => true,
-                            T_CLOSE_SHORT_ARRAY    => true,
-                            T_OPEN_TAG             => true,
-                            T_CLOSE_TAG            => true,
-                        ];
-
-                        $inTernary    = false;
-                        $lastEndToken = null;
-
-                        for ($scopeCloser = ($arrow + 1); $scopeCloser < $numTokens; $scopeCloser++) {
-                            // Arrow function closer should never be shared with the closer of a match
-                            // control structure.
-                            if (isset($this->tokens[$scopeCloser]['scope_closer'], $this->tokens[$scopeCloser]['scope_condition']) === true
-                                && $scopeCloser === $this->tokens[$scopeCloser]['scope_closer']
-                                && $this->tokens[$this->tokens[$scopeCloser]['scope_condition']]['code'] === T_MATCH
-                            ) {
-                                if ($arrow < $this->tokens[$scopeCloser]['scope_condition']) {
-                                    // Match in return value of arrow function. Move on to the next token.
-                                    continue;
-                                }
-
-                                // Arrow function as return value for the last match case without trailing comma.
-                                if ($lastEndToken !== null) {
-                                    $scopeCloser = $lastEndToken;
-                                    break;
-                                }
-
-                                for ($lastNonEmpty = ($scopeCloser - 1); $lastNonEmpty > $arrow; $lastNonEmpty--) {
-                                    if (isset(Tokens::$emptyTokens[$this->tokens[$lastNonEmpty]['code']]) === false) {
-                                        $scopeCloser = $lastNonEmpty;
-                                        break 2;
-                                    }
-                                }
-                            }
-
-                            if (isset($endTokens[$this->tokens[$scopeCloser]['code']]) === true) {
-                                if ($lastEndToken !== null
-                                    && ((isset($this->tokens[$scopeCloser]['parenthesis_opener']) === true
-                                    && $this->tokens[$scopeCloser]['parenthesis_opener'] < $arrow)
-                                    || (isset($this->tokens[$scopeCloser]['bracket_opener']) === true
-                                    && $this->tokens[$scopeCloser]['bracket_opener'] < $arrow))
-                                ) {
-                                    for ($lastNonEmpty = ($scopeCloser - 1); $lastNonEmpty > $arrow; $lastNonEmpty--) {
-                                        if (isset(Tokens::$emptyTokens[$this->tokens[$lastNonEmpty]['code']]) === false) {
-                                            $scopeCloser = $lastNonEmpty;
-                                            break;
-                                        }
-                                    }
-                                }
-
-                                break;
-                            }
-
-                            if ($inTernary === false
-                                && isset($this->tokens[$scopeCloser]['scope_closer'], $this->tokens[$scopeCloser]['scope_condition']) === true
-                                && $scopeCloser === $this->tokens[$scopeCloser]['scope_closer']
-                                && $this->tokens[$this->tokens[$scopeCloser]['scope_condition']]['code'] === T_FN
-                            ) {
-                                // Found a nested arrow function that already has the closer set and is in
-                                // the same scope as us, so we can use its closer.
-                                break;
-                            }
-
-                            if (isset($this->tokens[$scopeCloser]['scope_closer']) === true
-                                && $this->tokens[$scopeCloser]['code'] !== T_INLINE_ELSE
-                                && $this->tokens[$scopeCloser]['code'] !== T_END_HEREDOC
-                                && $this->tokens[$scopeCloser]['code'] !== T_END_NOWDOC
-                            ) {
-                                // We minus 1 here in case the closer can be shared with us.
-                                $scopeCloser = ($this->tokens[$scopeCloser]['scope_closer'] - 1);
-                                continue;
-                            }
-
-                            if (isset($this->tokens[$scopeCloser]['parenthesis_closer']) === true) {
-                                $scopeCloser  = $this->tokens[$scopeCloser]['parenthesis_closer'];
-                                $lastEndToken = $scopeCloser;
-                                continue;
-                            }
-
-                            if (isset($this->tokens[$scopeCloser]['bracket_closer']) === true) {
-                                $scopeCloser  = $this->tokens[$scopeCloser]['bracket_closer'];
-                                $lastEndToken = $scopeCloser;
-                                continue;
-                            }
-
-                            if ($this->tokens[$scopeCloser]['code'] === T_INLINE_THEN) {
-                                $inTernary = true;
-                                continue;
-                            }
-
-                            if ($this->tokens[$scopeCloser]['code'] === T_INLINE_ELSE) {
-                                if ($inTernary === false) {
-                                    break;
-                                }
-
-                                $inTernary = false;
-                                continue;
-                            }
-                        }//end for
-
-                        if ($scopeCloser !== $numTokens) {
-                            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                $line = $this->tokens[$i]['line'];
-                                echo "\t=> token $i on line $line processed as arrow function".PHP_EOL;
-                                echo "\t\t* scope opener set to $arrow *".PHP_EOL;
-                                echo "\t\t* scope closer set to $scopeCloser *".PHP_EOL;
-                                echo "\t\t* parenthesis opener set to $x *".PHP_EOL;
-                                echo "\t\t* parenthesis closer set to $closer *".PHP_EOL;
-                            }
-
-                            $this->tokens[$i]['code']            = T_FN;
-                            $this->tokens[$i]['type']            = 'T_FN';
-                            $this->tokens[$i]['scope_condition'] = $i;
-                            $this->tokens[$i]['scope_opener']    = $arrow;
-                            $this->tokens[$i]['scope_closer']    = $scopeCloser;
-                            $this->tokens[$i]['parenthesis_owner']  = $i;
-                            $this->tokens[$i]['parenthesis_opener'] = $x;
-                            $this->tokens[$i]['parenthesis_closer'] = $closer;
-
-                            $this->tokens[$arrow]['code'] = T_FN_ARROW;
-                            $this->tokens[$arrow]['type'] = 'T_FN_ARROW';
-
-                            $this->tokens[$arrow]['scope_condition']       = $i;
-                            $this->tokens[$arrow]['scope_opener']          = $arrow;
-                            $this->tokens[$arrow]['scope_closer']          = $scopeCloser;
-                            $this->tokens[$scopeCloser]['scope_condition'] = $i;
-                            $this->tokens[$scopeCloser]['scope_opener']    = $arrow;
-                            $this->tokens[$scopeCloser]['scope_closer']    = $scopeCloser;
-
-                            $opener = $this->tokens[$i]['parenthesis_opener'];
-                            $closer = $this->tokens[$i]['parenthesis_closer'];
-                            $this->tokens[$opener]['parenthesis_owner'] = $i;
-                            $this->tokens[$closer]['parenthesis_owner'] = $i;
-
-                            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                $line = $this->tokens[$arrow]['line'];
-                                echo "\t\t* token $arrow on line $line changed from T_DOUBLE_ARROW to T_FN_ARROW".PHP_EOL;
-                            }
-                        }//end if
-                    }//end if
-                }//end if
-
-                // If after all that, the extra tokens are not set, this is not a (valid) arrow function.
-                if (isset($this->tokens[$i]['scope_closer']) === false) {
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $line = $this->tokens[$i]['line'];
-                        echo "\t=> token $i on line $line is not an arrow function".PHP_EOL;
-                        echo "\t\t* token changed from T_FN to T_STRING".PHP_EOL;
-                    }
-
-                    $this->tokens[$i]['code'] = T_STRING;
-                    $this->tokens[$i]['type'] = 'T_STRING';
-                }
-            } else if ($this->tokens[$i]['code'] === T_OPEN_SQUARE_BRACKET) {
-                if (isset($this->tokens[$i]['bracket_closer']) === false) {
-                    continue;
-                }
-
-                // Unless there is a variable or a bracket before this token,
-                // it is the start of an array being defined using the short syntax.
-                $isShortArray = false;
-                $allowed      = [
-                    T_CLOSE_SQUARE_BRACKET     => T_CLOSE_SQUARE_BRACKET,
-                    T_CLOSE_CURLY_BRACKET      => T_CLOSE_CURLY_BRACKET,
-                    T_CLOSE_PARENTHESIS        => T_CLOSE_PARENTHESIS,
-                    T_VARIABLE                 => T_VARIABLE,
-                    T_OBJECT_OPERATOR          => T_OBJECT_OPERATOR,
-                    T_NULLSAFE_OBJECT_OPERATOR => T_NULLSAFE_OBJECT_OPERATOR,
-                    T_STRING                   => T_STRING,
-                    T_CONSTANT_ENCAPSED_STRING => T_CONSTANT_ENCAPSED_STRING,
-                    T_DOUBLE_QUOTED_STRING     => T_DOUBLE_QUOTED_STRING,
-                ];
-                $allowed     += Tokens::$magicConstants;
-
-                for ($x = ($i - 1); $x >= 0; $x--) {
-                    // If we hit a scope opener, the statement has ended
-                    // without finding anything, so it's probably an array
-                    // using PHP 7.1 short list syntax.
-                    if (isset($this->tokens[$x]['scope_opener']) === true) {
-                        $isShortArray = true;
-                        break;
-                    }
-
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) {
-                        // Allow for control structures without braces.
-                        if (($this->tokens[$x]['code'] === T_CLOSE_PARENTHESIS
-                            && isset($this->tokens[$x]['parenthesis_owner']) === true
-                            && isset(Tokens::$scopeOpeners[$this->tokens[$this->tokens[$x]['parenthesis_owner']]['code']]) === true)
-                            || isset($allowed[$this->tokens[$x]['code']]) === false
-                        ) {
-                            $isShortArray = true;
-                        }
-
-                        break;
-                    }
-                }//end for
-
-                if ($isShortArray === true) {
-                    $this->tokens[$i]['code'] = T_OPEN_SHORT_ARRAY;
-                    $this->tokens[$i]['type'] = 'T_OPEN_SHORT_ARRAY';
-
-                    $closer = $this->tokens[$i]['bracket_closer'];
-                    $this->tokens[$closer]['code'] = T_CLOSE_SHORT_ARRAY;
-                    $this->tokens[$closer]['type'] = 'T_CLOSE_SHORT_ARRAY';
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $line = $this->tokens[$i]['line'];
-                        echo "\t* token $i on line $line changed from T_OPEN_SQUARE_BRACKET to T_OPEN_SHORT_ARRAY".PHP_EOL;
-                        $line = $this->tokens[$closer]['line'];
-                        echo "\t* token $closer on line $line changed from T_CLOSE_SQUARE_BRACKET to T_CLOSE_SHORT_ARRAY".PHP_EOL;
-                    }
-                }
-
-                continue;
-            } else if ($this->tokens[$i]['code'] === T_MATCH) {
-                if (isset($this->tokens[$i]['scope_opener'], $this->tokens[$i]['scope_closer']) === false) {
-                    // Not a match expression after all.
-                    $this->tokens[$i]['code'] = T_STRING;
-                    $this->tokens[$i]['type'] = 'T_STRING';
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        echo "\t\t* token $i changed from T_MATCH to T_STRING".PHP_EOL;
-                    }
-
-                    if (isset($this->tokens[$i]['parenthesis_opener'], $this->tokens[$i]['parenthesis_closer']) === true) {
-                        $opener = $this->tokens[$i]['parenthesis_opener'];
-                        $closer = $this->tokens[$i]['parenthesis_closer'];
-                        unset(
-                            $this->tokens[$opener]['parenthesis_owner'],
-                            $this->tokens[$closer]['parenthesis_owner']
-                        );
-                        unset(
-                            $this->tokens[$i]['parenthesis_opener'],
-                            $this->tokens[$i]['parenthesis_closer'],
-                            $this->tokens[$i]['parenthesis_owner']
-                        );
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            echo "\t\t* cleaned parenthesis of token $i *".PHP_EOL;
-                        }
-                    }
-                } else {
-                    // Retokenize the double arrows for match expression cases to `T_MATCH_ARROW`.
-                    $searchFor  = [
-                        T_OPEN_CURLY_BRACKET  => T_OPEN_CURLY_BRACKET,
-                        T_OPEN_SQUARE_BRACKET => T_OPEN_SQUARE_BRACKET,
-                        T_OPEN_PARENTHESIS    => T_OPEN_PARENTHESIS,
-                        T_OPEN_SHORT_ARRAY    => T_OPEN_SHORT_ARRAY,
-                        T_DOUBLE_ARROW        => T_DOUBLE_ARROW,
-                    ];
-                    $searchFor += Tokens::$scopeOpeners;
-
-                    for ($x = ($this->tokens[$i]['scope_opener'] + 1); $x < $this->tokens[$i]['scope_closer']; $x++) {
-                        if (isset($searchFor[$this->tokens[$x]['code']]) === false) {
-                            continue;
-                        }
-
-                        if (isset($this->tokens[$x]['scope_closer']) === true) {
-                            $x = $this->tokens[$x]['scope_closer'];
-                            continue;
-                        }
-
-                        if (isset($this->tokens[$x]['parenthesis_closer']) === true) {
-                            $x = $this->tokens[$x]['parenthesis_closer'];
-                            continue;
-                        }
-
-                        if (isset($this->tokens[$x]['bracket_closer']) === true) {
-                            $x = $this->tokens[$x]['bracket_closer'];
-                            continue;
-                        }
-
-                        // This must be a double arrow, but make sure anyhow.
-                        if ($this->tokens[$x]['code'] === T_DOUBLE_ARROW) {
-                            $this->tokens[$x]['code'] = T_MATCH_ARROW;
-                            $this->tokens[$x]['type'] = 'T_MATCH_ARROW';
-
-                            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                                echo "\t\t* token $x changed from T_DOUBLE_ARROW to T_MATCH_ARROW".PHP_EOL;
-                            }
-                        }
-                    }//end for
-                }//end if
-
-                continue;
-            } else if ($this->tokens[$i]['code'] === T_BITWISE_OR
-                || $this->tokens[$i]['code'] === T_BITWISE_AND
-                || $this->tokens[$i]['code'] === T_CLOSE_PARENTHESIS
-            ) {
-                if ($lastSeenTypeToken < $i) {
-                    // We've already examined this code to check if it is a type declaration and concluded it wasn't.
-                    // No need to do it again.
-                    continue;
-                }
-
-                /*
-                    Convert "|" to T_TYPE_UNION or leave as T_BITWISE_OR.
-                    Convert "&" to T_TYPE_INTERSECTION or leave as T_BITWISE_AND.
-                    Convert "(" and ")" to T_TYPE_(OPEN|CLOSE)_PARENTHESIS or leave as T_(OPEN|CLOSE)_PARENTHESIS.
-
-                    All type related tokens will be converted in one go as soon as this section is hit.
-                */
-
-                $allowed = [
-                    T_STRING       => T_STRING,
-                    T_CALLABLE     => T_CALLABLE,
-                    T_SELF         => T_SELF,
-                    T_PARENT       => T_PARENT,
-                    T_STATIC       => T_STATIC,
-                    T_FALSE        => T_FALSE,
-                    T_TRUE         => T_TRUE,
-                    T_NULL         => T_NULL,
-                    T_NAMESPACE    => T_NAMESPACE,
-                    T_NS_SEPARATOR => T_NS_SEPARATOR,
-                ];
-
-                $suspectedType       = null;
-                $typeTokenCountAfter = 0;
-
-                for ($x = ($i + 1); $x < $numTokens; $x++) {
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === true) {
-                        continue;
-                    }
-
-                    if (isset($allowed[$this->tokens[$x]['code']]) === true) {
-                        ++$typeTokenCountAfter;
-                        continue;
-                    }
-
-                    if (($typeTokenCountAfter > 0
-                        || ($this->tokens[$i]['code'] === T_CLOSE_PARENTHESIS
-                        && isset($this->tokens[$i]['parenthesis_owner']) === false))
-                        && ($this->tokens[$x]['code'] === T_BITWISE_AND
-                        || $this->tokens[$x]['code'] === T_ELLIPSIS)
-                    ) {
-                        // Skip past reference and variadic indicators for parameter types.
-                        continue;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_VARIABLE) {
-                        // Parameter/Property defaults can not contain variables, so this could be a type.
-                        $suspectedType = 'property or parameter';
-                        break;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_DOUBLE_ARROW) {
-                        // Possible arrow function.
-                        $suspectedType = 'return';
-                        break;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_SEMICOLON) {
-                        // Possible abstract method or interface method.
-                        $suspectedType = 'return';
-                        break;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_OPEN_CURLY_BRACKET
-                        && isset($this->tokens[$x]['scope_condition']) === true
-                        && $this->tokens[$this->tokens[$x]['scope_condition']]['code'] === T_FUNCTION
-                    ) {
-                        $suspectedType = 'return';
-                        break;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_EQUAL) {
-                        // Possible constant declaration, the `T_STRING` name will have been skipped over already.
-                        $suspectedType = 'constant';
-                        break;
-                    }
-
-                    break;
-                }//end for
-
-                if (($typeTokenCountAfter === 0
-                    && ($this->tokens[$i]['code'] !== T_CLOSE_PARENTHESIS
-                    || isset($this->tokens[$i]['parenthesis_owner']) === true))
-                    || isset($suspectedType) === false
-                ) {
-                    // Definitely not a union, intersection or DNF type, move on.
-                    continue;
-                }
-
-                if ($suspectedType === 'property or parameter') {
-                    unset($allowed[T_STATIC]);
-                }
-
-                $typeTokenCountBefore = 0;
-                $typeOperators        = [$i];
-                $parenthesesCount     = 0;
-                $confirmed            = false;
-                $maybeNullable        = null;
-
-                if ($this->tokens[$i]['code'] === T_OPEN_PARENTHESIS || $this->tokens[$i]['code'] === T_CLOSE_PARENTHESIS) {
-                    ++$parenthesesCount;
-                }
-
-                for ($x = ($i - 1); $x >= 0; $x--) {
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === true) {
-                        continue;
-                    }
-
-                    if ($suspectedType === 'property or parameter'
-                        && $this->tokens[$x]['code'] === T_STRING
-                        && strtolower($this->tokens[$x]['content']) === 'static'
-                    ) {
-                        // Static keyword followed directly by an open parenthesis for a DNF type.
-                        // This token should be T_STATIC and was incorrectly identified as a function call before.
-                        $this->tokens[$x]['code'] = T_STATIC;
-                        $this->tokens[$x]['type'] = 'T_STATIC';
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$x]['line'];
-                            echo "\t* token $x on line $line changed back from T_STRING to T_STATIC".PHP_EOL;
-                        }
-                    }
-
-                    if ($suspectedType === 'property or parameter'
-                        && $this->tokens[$x]['code'] === T_OPEN_PARENTHESIS
-                    ) {
-                        // We need to prevent the open parenthesis for a function/fn declaration from being retokenized
-                        // to T_TYPE_OPEN_PARENTHESIS if this is the first parameter in the declaration.
-                        if (isset($this->tokens[$x]['parenthesis_owner']) === true
-                            && $this->tokens[$this->tokens[$x]['parenthesis_owner']]['code'] === T_FUNCTION
-                        ) {
-                            $confirmed = true;
-                            break;
-                        } else {
-                            // This may still be an arrow function which hasn't been handled yet.
-                            for ($y = ($x - 1); $y > 0; $y--) {
-                                if (isset(Tokens::$emptyTokens[$this->tokens[$y]['code']]) === false
-                                    && $this->tokens[$y]['code'] !== T_BITWISE_AND
-                                ) {
-                                    // Non-whitespace content.
-                                    break;
-                                }
-                            }
-
-                            if ($this->tokens[$y]['code'] === T_FN) {
-                                $confirmed = true;
-                                break;
-                            }
-                        }
-                    }//end if
-
-                    if (isset($allowed[$this->tokens[$x]['code']]) === true) {
-                        ++$typeTokenCountBefore;
-                        continue;
-                    }
-
-                    // Union, intersection and DNF types can't use the nullable operator, but be tolerant to parse errors.
-                    if (($typeTokenCountBefore > 0
-                        || ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS && isset($this->tokens[$x]['parenthesis_owner']) === false))
-                        && ($this->tokens[$x]['code'] === T_NULLABLE
-                        || $this->tokens[$x]['code'] === T_INLINE_THEN)
-                    ) {
-                        if ($this->tokens[$x]['code'] === T_INLINE_THEN) {
-                            $maybeNullable = $x;
-                        }
-
-                        continue;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_BITWISE_OR || $this->tokens[$x]['code'] === T_BITWISE_AND) {
-                        $typeOperators[] = $x;
-                        continue;
-                    }
-
-                    if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS || $this->tokens[$x]['code'] === T_CLOSE_PARENTHESIS) {
-                        ++$parenthesesCount;
-                        $typeOperators[] = $x;
-                        continue;
-                    }
-
-                    if ($suspectedType === 'return' && $this->tokens[$x]['code'] === T_COLON) {
-                        // Make sure this is the colon for a return type.
-                        for ($y = ($x - 1); $y > 0; $y--) {
-                            if (isset(Tokens::$emptyTokens[$this->tokens[$y]['code']]) === false) {
-                                break;
-                            }
-                        }
-
-                        if ($this->tokens[$y]['code'] !== T_CLOSE_PARENTHESIS) {
-                            // Definitely not a union, intersection or DNF return type, move on.
-                            continue 2;
-                        }
-
-                        if (isset($this->tokens[$y]['parenthesis_owner']) === true) {
-                            if ($this->tokens[$this->tokens[$y]['parenthesis_owner']]['code'] === T_FUNCTION
-                                || $this->tokens[$this->tokens[$y]['parenthesis_owner']]['code'] === T_CLOSURE
-                                || $this->tokens[$this->tokens[$y]['parenthesis_owner']]['code'] === T_FN
-                            ) {
-                                $confirmed = true;
-                            }
-
-                            break;
-                        }
-
-                        // Arrow functions may not have the parenthesis_owner set correctly yet.
-                        // Closure use tokens won't be parentheses owners until PHPCS 4.0.
-                        if (isset($this->tokens[$y]['parenthesis_opener']) === true) {
-                            for ($z = ($this->tokens[$y]['parenthesis_opener'] - 1); $z > 0; $z--) {
-                                if (isset(Tokens::$emptyTokens[$this->tokens[$z]['code']]) === false) {
-                                    break;
-                                }
-                            }
-
-                            if ($this->tokens[$z]['code'] === T_FN || $this->tokens[$z]['code'] === T_USE) {
-                                $confirmed = true;
-                            }
-                        }
-
-                        break;
-                    }//end if
-
-                    if ($suspectedType === 'constant' && $this->tokens[$x]['code'] === T_CONST) {
-                        $confirmed = true;
-                        break;
-                    }
-
-                    if ($suspectedType === 'property or parameter'
-                        && (isset(Tokens::$scopeModifiers[$this->tokens[$x]['code']]) === true
-                        || $this->tokens[$x]['code'] === T_VAR
-                        || $this->tokens[$x]['code'] === T_STATIC
-                        || $this->tokens[$x]['code'] === T_READONLY)
-                    ) {
-                        // This will also confirm constructor property promotion parameters, but that's fine.
-                        $confirmed = true;
-                    }
-
-                    break;
-                }//end for
-
-                // Remember the last token we examined as part of the (non-)"type declaration".
-                $lastSeenTypeToken = $x;
-
-                if ($confirmed === false
-                    && $suspectedType === 'property or parameter'
-                    && isset($this->tokens[$i]['nested_parenthesis']) === true
-                ) {
-                    $parens = $this->tokens[$i]['nested_parenthesis'];
-                    $last   = end($parens);
-
-                    if (isset($this->tokens[$last]['parenthesis_owner']) === true
-                        && $this->tokens[$this->tokens[$last]['parenthesis_owner']]['code'] === T_FUNCTION
-                    ) {
-                        $confirmed = true;
-                    } else {
-                        // No parenthesis owner set, this may be an arrow function which has not yet
-                        // had additional processing done.
-                        if (isset($this->tokens[$last]['parenthesis_opener']) === true) {
-                            for ($x = ($this->tokens[$last]['parenthesis_opener'] - 1); $x >= 0; $x--) {
-                                if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === true) {
-                                    continue;
-                                }
-
-                                break;
-                            }
-
-                            if ($this->tokens[$x]['code'] === T_FN) {
-                                for (--$x; $x >= 0; $x--) {
-                                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === true
-                                        || $this->tokens[$x]['code'] === T_BITWISE_AND
-                                    ) {
-                                        continue;
-                                    }
-
-                                    break;
-                                }
-
-                                if ($this->tokens[$x]['code'] !== T_FUNCTION) {
-                                    $confirmed = true;
-                                }
-                            }
-                        }//end if
-                    }//end if
-
-                    unset($parens, $last);
-                }//end if
-
-                if ($confirmed === false || ($parenthesesCount % 2) !== 0) {
-                    // Not a (valid) union, intersection or DNF type after all, move on.
-                    continue;
-                }
-
-                foreach ($typeOperators as $x) {
-                    if ($this->tokens[$x]['code'] === T_BITWISE_OR) {
-                        $this->tokens[$x]['code'] = T_TYPE_UNION;
-                        $this->tokens[$x]['type'] = 'T_TYPE_UNION';
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$x]['line'];
-                            echo "\t* token $x on line $line changed from T_BITWISE_OR to T_TYPE_UNION".PHP_EOL;
-                        }
-                    } else if ($this->tokens[$x]['code'] === T_BITWISE_AND) {
-                        $this->tokens[$x]['code'] = T_TYPE_INTERSECTION;
-                        $this->tokens[$x]['type'] = 'T_TYPE_INTERSECTION';
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$x]['line'];
-                            echo "\t* token $x on line $line changed from T_BITWISE_AND to T_TYPE_INTERSECTION".PHP_EOL;
-                        }
-                    } else if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS) {
-                        $this->tokens[$x]['code'] = T_TYPE_OPEN_PARENTHESIS;
-                        $this->tokens[$x]['type'] = 'T_TYPE_OPEN_PARENTHESIS';
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$x]['line'];
-                            echo "\t* token $x on line $line changed from T_OPEN_PARENTHESIS to T_TYPE_OPEN_PARENTHESIS".PHP_EOL;
-                        }
-                    } else if ($this->tokens[$x]['code'] === T_CLOSE_PARENTHESIS) {
-                        $this->tokens[$x]['code'] = T_TYPE_CLOSE_PARENTHESIS;
-                        $this->tokens[$x]['type'] = 'T_TYPE_CLOSE_PARENTHESIS';
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line = $this->tokens[$x]['line'];
-                            echo "\t* token $x on line $line changed from T_CLOSE_PARENTHESIS to T_TYPE_CLOSE_PARENTHESIS".PHP_EOL;
-                        }
-                    }//end if
-                }//end foreach
-
-                if (isset($maybeNullable) === true) {
-                    $this->tokens[$maybeNullable]['code'] = T_NULLABLE;
-                    $this->tokens[$maybeNullable]['type'] = 'T_NULLABLE';
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $line = $this->tokens[$maybeNullable]['line'];
-                        echo "\t* token $maybeNullable on line $line changed from T_INLINE_THEN to T_NULLABLE".PHP_EOL;
-                    }
-                }
-
-                continue;
-            } else if ($this->tokens[$i]['code'] === T_STATIC) {
-                for ($x = ($i - 1); $x > 0; $x--) {
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) {
-                        break;
-                    }
-                }
-
-                if ($this->tokens[$x]['code'] === T_INSTANCEOF) {
-                    $this->tokens[$i]['code'] = T_STRING;
-                    $this->tokens[$i]['type'] = 'T_STRING';
-
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $line = $this->tokens[$i]['line'];
-                        echo "\t* token $i on line $line changed from T_STATIC to T_STRING".PHP_EOL;
-                    }
-                }
-
-                continue;
-            } else if ($this->tokens[$i]['code'] === T_TRUE
-                || $this->tokens[$i]['code'] === T_FALSE
-                || $this->tokens[$i]['code'] === T_NULL
-            ) {
-                for ($x = ($i + 1); $x < $numTokens; $x++) {
-                    if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) {
-                        // Non-whitespace content.
-                        break;
-                    }
-                }
-
-                if ($x !== $numTokens
-                    && isset($this->tstringContexts[$this->tokens[$x]['code']]) === true
-                ) {
-                    if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                        $line = $this->tokens[$i]['line'];
-                        $type = $this->tokens[$i]['type'];
-                        echo "\t* token $i on line $line changed from $type to T_STRING".PHP_EOL;
-                    }
-
-                    $this->tokens[$i]['code'] = T_STRING;
-                    $this->tokens[$i]['type'] = 'T_STRING';
-                }
-            }//end if
-
-            if (($this->tokens[$i]['code'] !== T_CASE
-                && $this->tokens[$i]['code'] !== T_DEFAULT)
-                || isset($this->tokens[$i]['scope_opener']) === false
-            ) {
-                // Only interested in CASE and DEFAULT statements from here on in.
-                continue;
-            }
-
-            $scopeOpener = $this->tokens[$i]['scope_opener'];
-            $scopeCloser = $this->tokens[$i]['scope_closer'];
-
-            // If the first char after the opener is a curly brace
-            // and that brace has been ignored, it is actually
-            // opening this case statement and the opener and closer are
-            // probably set incorrectly.
-            for ($x = ($scopeOpener + 1); $x < $numTokens; $x++) {
-                if (isset(Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) {
-                    // Non-whitespace content.
-                    break;
-                }
-            }
-
-            if ($this->tokens[$x]['code'] === T_CASE || $this->tokens[$x]['code'] === T_DEFAULT) {
-                // Special case for multiple CASE statements that share the same
-                // closer. Because we are going backwards through the file, this next
-                // CASE statement is already fixed, so just use its closer and don't
-                // worry about fixing anything.
-                $newCloser = $this->tokens[$x]['scope_closer'];
-                $this->tokens[$i]['scope_closer'] = $newCloser;
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    $oldType = $this->tokens[$scopeCloser]['type'];
-                    $newType = $this->tokens[$newCloser]['type'];
-                    $line    = $this->tokens[$i]['line'];
-                    echo "\t* token $i (T_CASE) on line $line closer changed from $scopeCloser ($oldType) to $newCloser ($newType)".PHP_EOL;
-                }
-
-                continue;
-            }
-
-            if ($this->tokens[$x]['code'] !== T_OPEN_CURLY_BRACKET
-                || isset($this->tokens[$x]['scope_condition']) === true
-            ) {
-                // Not a CASE/DEFAULT with a curly brace opener.
-                continue;
-            }
-
-            // The closer for this CASE/DEFAULT should be the closing curly brace and
-            // not whatever it already is. The opener needs to be the opening curly
-            // brace so everything matches up.
-            $newCloser = $this->tokens[$x]['bracket_closer'];
-            foreach ([$i, $x, $newCloser] as $index) {
-                $this->tokens[$index]['scope_condition'] = $i;
-                $this->tokens[$index]['scope_opener']    = $x;
-                $this->tokens[$index]['scope_closer']    = $newCloser;
-            }
-
-            if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                $line      = $this->tokens[$i]['line'];
-                $tokenType = $this->tokens[$i]['type'];
-
-                $oldType = $this->tokens[$scopeOpener]['type'];
-                $newType = $this->tokens[$x]['type'];
-                echo "\t* token $i ($tokenType) on line $line opener changed from $scopeOpener ($oldType) to $x ($newType)".PHP_EOL;
-
-                $oldType = $this->tokens[$scopeCloser]['type'];
-                $newType = $this->tokens[$newCloser]['type'];
-                echo "\t* token $i ($tokenType) on line $line closer changed from $scopeCloser ($oldType) to $newCloser ($newType)".PHP_EOL;
-            }
-
-            if ($this->tokens[$scopeOpener]['scope_condition'] === $i) {
-                unset($this->tokens[$scopeOpener]['scope_condition']);
-                unset($this->tokens[$scopeOpener]['scope_opener']);
-                unset($this->tokens[$scopeOpener]['scope_closer']);
-            }
-
-            if ($this->tokens[$scopeCloser]['scope_condition'] === $i) {
-                unset($this->tokens[$scopeCloser]['scope_condition']);
-                unset($this->tokens[$scopeCloser]['scope_opener']);
-                unset($this->tokens[$scopeCloser]['scope_closer']);
-            } else {
-                // We were using a shared closer. All tokens that were
-                // sharing this closer with us, except for the scope condition
-                // and it's opener, need to now point to the new closer.
-                $condition = $this->tokens[$scopeCloser]['scope_condition'];
-                $start     = ($this->tokens[$condition]['scope_opener'] + 1);
-                for ($y = $start; $y < $scopeCloser; $y++) {
-                    if (isset($this->tokens[$y]['scope_closer']) === true
-                        && $this->tokens[$y]['scope_closer'] === $scopeCloser
-                    ) {
-                        $this->tokens[$y]['scope_closer'] = $newCloser;
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $line      = $this->tokens[$y]['line'];
-                            $tokenType = $this->tokens[$y]['type'];
-                            $oldType   = $this->tokens[$scopeCloser]['type'];
-                            $newType   = $this->tokens[$newCloser]['type'];
-                            echo "\t\t* token $y ($tokenType) on line $line closer changed from $scopeCloser ($oldType) to $newCloser ($newType)".PHP_EOL;
-                        }
-                    }
-                }
-            }//end if
-
-            unset($this->tokens[$x]['bracket_opener']);
-            unset($this->tokens[$x]['bracket_closer']);
-            unset($this->tokens[$newCloser]['bracket_opener']);
-            unset($this->tokens[$newCloser]['bracket_closer']);
-            $this->tokens[$scopeCloser]['conditions'][] = $i;
-
-            // Now fix up all the tokens that think they are
-            // inside the CASE/DEFAULT statement when they are really outside.
-            for ($x = $newCloser; $x < $scopeCloser; $x++) {
-                foreach ($this->tokens[$x]['conditions'] as $num => $oldCond) {
-                    if ($oldCond === $this->tokens[$i]['code']) {
-                        $oldConditions = $this->tokens[$x]['conditions'];
-                        unset($this->tokens[$x]['conditions'][$num]);
-
-                        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                            $type     = $this->tokens[$x]['type'];
-                            $oldConds = '';
-                            foreach ($oldConditions as $condition) {
-                                $oldConds .= Tokens::tokenName($condition).',';
-                            }
-
-                            $oldConds = rtrim($oldConds, ',');
-
-                            $newConds = '';
-                            foreach ($this->tokens[$x]['conditions'] as $condition) {
-                                $newConds .= Tokens::tokenName($condition).',';
-                            }
-
-                            $newConds = rtrim($newConds, ',');
-
-                            echo "\t\t* cleaned $x ($type) *".PHP_EOL;
-                            echo "\t\t\t=> conditions changed from $oldConds to $newConds".PHP_EOL;
-                        }
-
-                        break;
-                    }//end if
-                }//end foreach
-            }//end for
-        }//end for
-
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            echo "\t*** END ADDITIONAL PHP PROCESSING ***".PHP_EOL;
-        }
-
-    }//end processAdditional()
-
-
-    /**
-     * Takes a token produced from <code>token_get_all()</code> and produces a
-     * more uniform token.
-     *
-     * @param string|array $token The token to convert.
-     *
-     * @return array The new token.
-     */
-    public static function standardiseToken($token)
-    {
-        if (isset($token[1]) === false) {
-            if (isset(self::$resolveTokenCache[$token[0]]) === true) {
-                return self::$resolveTokenCache[$token[0]];
-            }
-        } else {
-            $cacheKey = null;
-            if ($token[0] === T_STRING) {
-                $cacheKey = strtolower($token[1]);
-            } else if ($token[0] !== T_CURLY_OPEN) {
-                $cacheKey = $token[0];
-            }
-
-            if ($cacheKey !== null && isset(self::$resolveTokenCache[$cacheKey]) === true) {
-                $newToken            = self::$resolveTokenCache[$cacheKey];
-                $newToken['content'] = $token[1];
-                return $newToken;
-            }
-        }
-
-        if (isset($token[1]) === false) {
-            return self::resolveSimpleToken($token[0]);
-        }
-
-        if ($token[0] === T_STRING) {
-            switch ($cacheKey) {
-            case 'false':
-                $newToken['type'] = 'T_FALSE';
-                break;
-            case 'true':
-                $newToken['type'] = 'T_TRUE';
-                break;
-            case 'null':
-                $newToken['type'] = 'T_NULL';
-                break;
-            case 'self':
-                $newToken['type'] = 'T_SELF';
-                break;
-            case 'parent':
-                $newToken['type'] = 'T_PARENT';
-                break;
-            default:
-                $newToken['type'] = 'T_STRING';
-                break;
-            }
-
-            $newToken['code'] = constant($newToken['type']);
-
-            self::$resolveTokenCache[$cacheKey] = $newToken;
-        } else if ($token[0] === T_CURLY_OPEN) {
-            $newToken = [
-                'code' => T_OPEN_CURLY_BRACKET,
-                'type' => 'T_OPEN_CURLY_BRACKET',
-            ];
-        } else {
-            $newToken = [
-                'code' => $token[0],
-                'type' => Tokens::tokenName($token[0]),
-            ];
-
-            self::$resolveTokenCache[$token[0]] = $newToken;
-        }//end if
-
-        $newToken['content'] = $token[1];
-        return $newToken;
-
-    }//end standardiseToken()
-
-
-    /**
-     * Converts simple tokens into a format that conforms to complex tokens
-     * produced by token_get_all().
-     *
-     * Simple tokens are tokens that are not in array form when produced from
-     * token_get_all().
-     *
-     * @param string $token The simple token to convert.
-     *
-     * @return array The new token in array format.
-     */
-    public static function resolveSimpleToken($token)
-    {
-        $newToken = [];
-
-        switch ($token) {
-        case '{':
-            $newToken['type'] = 'T_OPEN_CURLY_BRACKET';
-            break;
-        case '}':
-            $newToken['type'] = 'T_CLOSE_CURLY_BRACKET';
-            break;
-        case '[':
-            $newToken['type'] = 'T_OPEN_SQUARE_BRACKET';
-            break;
-        case ']':
-            $newToken['type'] = 'T_CLOSE_SQUARE_BRACKET';
-            break;
-        case '(':
-            $newToken['type'] = 'T_OPEN_PARENTHESIS';
-            break;
-        case ')':
-            $newToken['type'] = 'T_CLOSE_PARENTHESIS';
-            break;
-        case ':':
-            $newToken['type'] = 'T_COLON';
-            break;
-        case '.':
-            $newToken['type'] = 'T_STRING_CONCAT';
-            break;
-        case ';':
-            $newToken['type'] = 'T_SEMICOLON';
-            break;
-        case '=':
-            $newToken['type'] = 'T_EQUAL';
-            break;
-        case '*':
-            $newToken['type'] = 'T_MULTIPLY';
-            break;
-        case '/':
-            $newToken['type'] = 'T_DIVIDE';
-            break;
-        case '+':
-            $newToken['type'] = 'T_PLUS';
-            break;
-        case '-':
-            $newToken['type'] = 'T_MINUS';
-            break;
-        case '%':
-            $newToken['type'] = 'T_MODULUS';
-            break;
-        case '^':
-            $newToken['type'] = 'T_BITWISE_XOR';
-            break;
-        case '&':
-            $newToken['type'] = 'T_BITWISE_AND';
-            break;
-        case '|':
-            $newToken['type'] = 'T_BITWISE_OR';
-            break;
-        case '~':
-            $newToken['type'] = 'T_BITWISE_NOT';
-            break;
-        case '<':
-            $newToken['type'] = 'T_LESS_THAN';
-            break;
-        case '>':
-            $newToken['type'] = 'T_GREATER_THAN';
-            break;
-        case '!':
-            $newToken['type'] = 'T_BOOLEAN_NOT';
-            break;
-        case ',':
-            $newToken['type'] = 'T_COMMA';
-            break;
-        case '@':
-            $newToken['type'] = 'T_ASPERAND';
-            break;
-        case '$':
-            $newToken['type'] = 'T_DOLLAR';
-            break;
-        case '`':
-            $newToken['type'] = 'T_BACKTICK';
-            break;
-        default:
-            $newToken['type'] = 'T_NONE';
-            break;
-        }//end switch
-
-        $newToken['code']    = constant($newToken['type']);
-        $newToken['content'] = $token;
-
-        self::$resolveTokenCache[$token] = $newToken;
-        return $newToken;
-
-    }//end resolveSimpleToken()
-
-
-    /**
-     * Finds a "closer" token (closing parenthesis or square bracket for example)
-     * Handle parenthesis balancing while searching for closing token
-     *
-     * @param array           $tokens       The list of tokens to iterate searching the closing token (as returned by token_get_all).
-     * @param int             $start        The starting position.
-     * @param string|string[] $openerTokens The opening character.
-     * @param string          $closerChar   The closing character.
-     *
-     * @return int|null The position of the closing token, if found. NULL otherwise.
-     */
-    private function findCloser(array &$tokens, $start, $openerTokens, $closerChar)
-    {
-        $numTokens    = count($tokens);
-        $stack        = [0];
-        $closer       = null;
-        $openerTokens = (array) $openerTokens;
-
-        for ($x = $start; $x < $numTokens; $x++) {
-            if (in_array($tokens[$x], $openerTokens, true) === true
-                || (is_array($tokens[$x]) === true && in_array($tokens[$x][1], $openerTokens, true) === true)
-            ) {
-                $stack[] = $x;
-            } else if ($tokens[$x] === $closerChar) {
-                array_pop($stack);
-                if (empty($stack) === true) {
-                    $closer = $x;
-                    break;
-                }
-            }
-        }
-
-        return $closer;
-
-    }//end findCloser()
-
-
-    /**
-     * PHP 8 attributes parser for PHP < 8
-     * Handles single-line and multiline attributes.
-     *
-     * @param array $tokens   The original array of tokens (as returned by token_get_all).
-     * @param int   $stackPtr The current position in token array.
-     *
-     * @return array|null The array of parsed attribute tokens
-     */
-    private function parsePhpAttribute(array &$tokens, $stackPtr)
-    {
-
-        $token = $tokens[$stackPtr];
-
-        $commentBody = substr($token[1], 2);
-        $subTokens   = @token_get_all('<?php '.$commentBody);
-
-        foreach ($subTokens as $i => $subToken) {
-            if (is_array($subToken) === true
-                && $subToken[0] === T_COMMENT
-                && strpos($subToken[1], '#[') === 0
-            ) {
-                $reparsed = $this->parsePhpAttribute($subTokens, $i);
-                if ($reparsed !== null) {
-                    array_splice($subTokens, $i, 1, $reparsed);
-                } else {
-                    $subToken[0] = T_ATTRIBUTE;
-                }
-            }
-        }
-
-        array_splice($subTokens, 0, 1, [[T_ATTRIBUTE, '#[']]);
-
-        // Go looking for the close bracket.
-        $bracketCloser = $this->findCloser($subTokens, 1, '[', ']');
-        if (PHP_VERSION_ID < 80000 && $bracketCloser === null) {
-            foreach (array_slice($tokens, ($stackPtr + 1)) as $token) {
-                if (is_array($token) === true) {
-                    $commentBody .= $token[1];
-                } else {
-                    $commentBody .= $token;
-                }
-            }
-
-            $subTokens = @token_get_all('<?php '.$commentBody);
-            array_splice($subTokens, 0, 1, [[T_ATTRIBUTE, '#[']]);
-
-            $bracketCloser = $this->findCloser($subTokens, 1, '[', ']');
-            if ($bracketCloser !== null) {
-                array_splice($tokens, ($stackPtr + 1), count($tokens), array_slice($subTokens, ($bracketCloser + 1)));
-                $subTokens = array_slice($subTokens, 0, ($bracketCloser + 1));
-            }
-        }
-
-        if ($bracketCloser === null) {
-            return null;
-        }
-
-        return $subTokens;
-
-    }//end parsePhpAttribute()
-
-
-    /**
-     * Creates a map for the attributes tokens that surround other tokens.
-     *
-     * @return void
-     */
-    private function createAttributesNestingMap()
-    {
-        $map = [];
-        for ($i = 0; $i < $this->numTokens; $i++) {
-            if (isset($this->tokens[$i]['attribute_opener']) === true
-                && $i === $this->tokens[$i]['attribute_opener']
-            ) {
-                if (empty($map) === false) {
-                    $this->tokens[$i]['nested_attributes'] = $map;
-                }
-
-                if (isset($this->tokens[$i]['attribute_closer']) === true) {
-                    $map[$this->tokens[$i]['attribute_opener']]
-                        = $this->tokens[$i]['attribute_closer'];
-                }
-            } else if (isset($this->tokens[$i]['attribute_closer']) === true
-                && $i === $this->tokens[$i]['attribute_closer']
-            ) {
-                array_pop($map);
-                if (empty($map) === false) {
-                    $this->tokens[$i]['nested_attributes'] = $map;
-                }
-            } else {
-                if (empty($map) === false) {
-                    $this->tokens[$i]['nested_attributes'] = $map;
-                }
-            }//end if
-        }//end for
-
-    }//end createAttributesNestingMap()
-
-
-}//end class