1908500122

Build # 1908500122

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/PHPCSStandards/PHPCSUtils/commit/<a class=hub.com/PHPCSStandards/PHPCSUtils/commit/ada08ad57d1249983e2ac34576df1fb0ed9603bd">ada08ad57<a href="https://github.com/PHPCSStandards/PHPCSUtils/commit/ada08ad57d1249983e2ac34576df1fb0ed9603bd">">Merge </a><a class="double-link" href="https://github.com/PHPCSStandards/PHPCSUtils/commit/<a class="double-link" href="https://github.com/PHPCSStandards/PHPCSUtils/commit/52c2176818dd579a17bd69178dd27b76a71a131d">52c217681</a>">52c217681</a><a href="https://github.com/PHPCSStandards/PHPCSUtils/commit/ada08ad57d1249983e2ac34576df1fb0ed9603bd"> into c9d479411">c9d479411</a>

Pull Request Pull Request #293: PHP 8.1 | Numbers: add support for explicit octal notation

Run Details

16 of 23 new or added lines in 1 file covered. (69.57%)

2743 of 2833 relevant lines covered (96.82%)

88.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.3

/PHPCSUtils/Utils/Numbers.php

<?php
/**
 * PHPCSUtils, utility functions and classes for PHP_CodeSniffer sniff developers.
 *
 * @package   PHPCSUtils
 * @copyright 2019-2020 PHPCSUtils Contributors
 * @license   https://opensource.org/licenses/LGPL-3.0 LGPL3
 * @link      https://github.com/PHPCSStandards/PHPCSUtils
 */

namespace PHPCSUtils\Utils;

use PHP_CodeSniffer\Exceptions\RuntimeException;
use PHP_CodeSniffer\Files\File;
use PHPCSUtils\BackCompat\Helper;

/**
 * Utility functions for working with integer/float tokens.
 *
 * PHP 7.4 introduced numeric literal separators which break number tokenization in older PHP versions.
 * PHPCS backfills this since PHPCS 3.5.3/4.
 *
 * Along the same lines, PHP 8.1 introduced an explicit octal notation which also breaks number tokenization
 * in older PHP versions. This is backfilled in PHPCS since PHPCS 3.7.0.
 *
 * In other words, if an external standard intends to support PHPCS < 3.7.0 and PHP < 8.1, working
 * with number tokens has suddenly become a challenge.
 *
 * The functions in this class have been put in place to ease that pain and it is
 * *strongly* recommended to always use these functions when sniffing for and examining the
 * contents of `T_LNUMBER` or `T_DNUMBER` tokens.
 *
 * @link https://www.php.net/migration74.new-features.php#migration74.new-features.core.numeric-literal-separator
 *       PHP Manual on numeric literal separators.
 * @link https://www.php.net/manual/en/migration81.new-features.php#migration81.new-features.core.octal-literal-prefix
 *       PHP Manual on the introduction of the integer octal literal prefix.
 *
 * @since 1.0.0
 */
class Numbers
{

    /**
     * Regex to determine whether the contents of an arbitrary string represents a decimal integer.
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_DECIMAL_INT = '`^(?:0|[1-9][0-9]*)$`D';

    /**
     * Regex to determine whether the contents of an arbitrary string represents an octal integer.
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_OCTAL_INT = '`^0[o]?[0-7]+$`iD';

    /**
     * Regex to determine whether the contents of an arbitrary string represents a binary integer.
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_BINARY_INT = '`^0b[0-1]+$`iD';

    /**
     * Regex to determine whether the contents of an arbitrary string represents a hexidecimal integer.
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_HEX_INT = '`^0x[0-9A-F]+$`iD';

    /**
     * Regex to determine whether the contents of an arbitrary string represents a float.
     *
     * @link https://www.php.net/language.types.float PHP Manual on floats
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_FLOAT = '`
        ^(?:
            (?:
                (?:
                    (?P<LNUM>[0-9]+)
                |
                    (?P<DNUM>([0-9]*\.(?P>LNUM)|(?P>LNUM)\.[0-9]*))
                )
                [e][+-]?(?P>LNUM)
            )
            |
            (?P>DNUM)
            |
            (?:0|[1-9][0-9]*)
        )$
        `ixD';

    /**
     * Regex to determine if a T_STRING following a T_[DL]NUMBER is part of a numeric literal sequence.
     *
     * Cross-version compatibility helper for PHP 7.4 numeric literals with underscore separators.
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_NUMLIT_STRING = '`^((?<![\.e])_[0-9][0-9e\.]*)+$`iD';

    /**
     * Regex to determine is a T_STRING following a T_[DL]NUMBER is part of a hexidecimal numeric literal sequence.
     *
     * Cross-version compatibility helper for PHP 7.4 numeric literals with underscore separators.
     *
     * @since 1.0.0
     *
     * @var string
     */
    const REGEX_HEX_NUMLIT_STRING = '`^((?<!\.)_[0-9A-F]*)+$`iD';

    /**
     * PHPCS versions in which the backfill for PHP 7.4 numeric literal separators is broken.
     *
     * @since 1.0.0
     * @since 1.0.0-alpha2 Changed from a property to a class constant.
     *                     Changed from an array to a string.
     *
     * @var string
     */
    const UNSUPPORTED_PHPCS_VERSION = '3.5.3';

    /**
     * Valid tokens which could be part of a numeric literal sequence in PHP < 7.4.
     *
     * @since 1.0.0
     *
     * @var array
     */
    private static $numericLiteralAcceptedTokens = [
        \T_LNUMBER => true,
        \T_DNUMBER => true,
        \T_STRING  => true,
    ];

    /**
     * Retrieve information about a number token in a cross-version compatible manner.
     *
     * Helper function to deal with numeric literals, potentially with underscore separators
     * and/or explicit octal notation.
     *
     * PHP < 7.4 does not tokenize numeric literals containing underscores correctly.
     * As of PHPCS 3.5.3, PHPCS contains a backfill, but this backfill was buggy in the initial
     * implementation. A fix for this broken backfill is included in PHPCS 3.5.4.
     *
     * PHP < 8.1 does not tokenize explicit octal notation for literal integers correctly.
     * PHPCS backfills this as of PHPCS 3.7.0.
     *
     * Either way, this function can be used with all PHPCS/PHP combinations and will, if necessary,
     * provide a backfill for PHPCS/PHP combinations where PHP 7.4 numbers with underscore separators
     * and/or octals using the explicit octal prefix, are tokenized incorrectly - with the exception
     * of PHPCS 3.5.3 as the buggyness of the original backfill implementation makes it impossible
     * to provide reliable results.
     *
     * @link https://github.com/squizlabs/PHP_CodeSniffer/issues/2546 PHPCS issue #2546
     * @link https://github.com/squizlabs/PHP_CodeSniffer/pull/2771   PHPCS PR #2771
     * @link https://github.com/squizlabs/PHP_CodeSniffer/pull/3481   PHPCS PR #3481
     * @link https://github.com/squizlabs/PHP_CodeSniffer/pull/3552   PHPCS PR #3552
     *
     * @since 1.0.0
     *
     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
     * @param int                         $stackPtr  The position of a T_LNUMBER or T_DNUMBER token.
     *
     * @return array An array with information about the number.
     *               The format of the array return value is:
     *               ```php
     *               array(
     *                 'orig_content' => string, // The (potentially concatenated) original
     *                                           // content of the tokens;
     *                 'content'      => string, // The (potentially concatenated) content,
     *                                           // underscore(s) removed;
     *                 'code'         => int,    // The token code of the number, either
     *                                           // T_LNUMBER or T_DNUMBER.
     *                 'type'         => string, // The token type, either 'T_LNUMBER'
     *                                           // or 'T_DNUMBER'.
     *                 'decimal'      => string, // The decimal value of the number;
     *                 'last_token'   => int,    // The stackPtr to the last token which was
     *                                           // part of the number.
     *                                           // This will be the same as the original
     *                                           // stackPtr if it is not a PHP 7.4 number
     *                                           // with underscores.
     *               )
     *               ```
     *
     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified token is not of type
     *                                                      `T_LNUMBER` or `T_DNUMBER`.
     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If this function is called in combination
     *                                                      with an unsupported PHPCS version.
     */
    public static function getCompleteNumber(File $phpcsFile, $stackPtr)
    {
        static $php74, $php81, $phpcsVersion, $phpcsWithBackfill, $phpcsWithOctalSupport;

        $tokens = $phpcsFile->getTokens();

        if (isset($tokens[$stackPtr]) === false
            || ($tokens[$stackPtr]['code'] !== \T_LNUMBER && $tokens[$stackPtr]['code'] !== \T_DNUMBER)
        ) {
            throw new RuntimeException(
                'Token type "' . $tokens[$stackPtr]['type'] . '" is not T_LNUMBER or T_DNUMBER'
            );
        }

        if (isset($php74, $php81, $phpcsVersion, $phpcsWithBackfill, $phpcsWithOctalSupport) === false) {
            $php74                 = \version_compare(\PHP_VERSION_ID, '70399', '>');
            $php81                 = \version_compare(\PHP_VERSION_ID, '80099', '>');
            $phpcsVersion          = Helper::getVersion();
            $phpcsWithBackfill     = \version_compare($phpcsVersion, self::UNSUPPORTED_PHPCS_VERSION, '>');
            $phpcsWithOctalSupport = \version_compare($phpcsVersion, '3.7.0', '>=');
        }

        /*
         * Bow out for PHPCS version(s) with broken tokenization of PHP 7.4 numeric literals with
         * separators, including for PHP 7.4, as the backfill kicks in for PHP 7.4 while it shouldn't.
         *
         * @link https://github.com/squizlabs/PHP_CodeSniffer/issues/2546
         */
        if (\version_compare($phpcsVersion, self::UNSUPPORTED_PHPCS_VERSION, '==') === true) {
            throw new RuntimeException('The ' . __METHOD__ . '() method does not support PHPCS ' . $phpcsVersion);
        }

        $content = $tokens[$stackPtr]['content'];
        $result  = [
            'orig_content' => $content,
            'content'      => \str_replace('_', '', $content),
            'code'         => $tokens[$stackPtr]['code'],
            'type'         => $tokens[$stackPtr]['type'],
            'decimal'      => self::getDecimalValue($content),
            'last_token'   => $stackPtr,
        ];

        /*
         * When things are already correctly tokenized for both situations handled by this method,
         * there's not much to do.
         */
        if ($php81 === true || $phpcsWithOctalSupport === true) {
            return $result;
        }

        /*
         * Potentially handle explicit octal notation.
         */
        if (isset($tokens[($stackPtr + 1)]) === true
            && $tokens[($stackPtr + 1)]['code'] === \T_STRING
            && \strtolower($tokens[($stackPtr + 1)]['content'][0]) === 'o'
            && $tokens[($stackPtr + 1)]['content'][1] !== '_'
        ) {
            $content .= $tokens[($stackPtr + 1)]['content'];
            $result   = self::updateResult($result, $content, ($stackPtr + 1), true);
        }

        /*
         * Check if numeric literal notation needs handling.
         */
        if ($php74 === true
            || $phpcsWithBackfill === true
            || isset($tokens[($result['last_token'] + 1)]) === false
            || $tokens[($result['last_token'] + 1)]['code'] !== \T_STRING
            || $tokens[($result['last_token'] + 1)]['content'][0] !== '_'
        ) {
            return $result;
        }

        $hex = false;
        if (\strpos($content, '0x') === 0) {
            $hex = true;
        }

        $lastChar = \substr($content, -1);
        if (\preg_match('`[0-9]`', $lastChar) !== 1) {
            if ($hex === false || \preg_match('`[A-F]`i', $lastChar) !== 1) {
                // Last character not valid for numeric literal sequence with underscores.
                // No need to look any further.
                return $result;
            }
        }

        /*
         * OK, so this could potentially be a PHP 7.4 number with an underscore separator with PHPCS
         * being run on PHP < 7.4.
         */

        $regex = self::REGEX_NUMLIT_STRING;
        if ($hex === true) {
            $regex = self::REGEX_HEX_NUMLIT_STRING;
        }

        $next      = $result['last_token'];
        $lastToken = $result['last_token'];

        while (isset($tokens[++$next], self::$numericLiteralAcceptedTokens[$tokens[$next]['code']]) === true) {
            if ($tokens[$next]['code'] === \T_STRING
                && \preg_match($regex, $tokens[$next]['content']) !== 1
            ) {
                break;
            }

            $content  .= $tokens[$next]['content'];
            $lastToken = $next;
            $lastChar  = \substr(\strtolower($content), -1);

            // Support floats.
            if ($lastChar === 'e'
                && isset($tokens[($next + 1)], $tokens[($next + 2)]) === true
                && ($tokens[($next + 1)]['code'] === \T_MINUS
                || $tokens[($next + 1)]['code'] === \T_PLUS)
                && $tokens[($next + 2)]['code'] === \T_LNUMBER
            ) {
                $content  .= $tokens[($next + 1)]['content'];
                $content  .= $tokens[($next + 2)]['content'];
                $next     += 2;
                $lastToken = $next;
            }

            // Don't look any further if the last char is not valid before a separator.
            if (\preg_match('`[0-9]`', $lastChar) !== 1) {
                if ($hex === false || \preg_match('`[a-f]`i', $lastChar) !== 1) {
                    break;
                }
            }
        }

        return self::updateResult($result, $content, $lastToken, $hex);
    }

    /**
     * Helper function to update the result array for the getCompleteNumber() method.
     *
     * @param array  $result     Current result array.
     * @param string $newContent The new content for the number to update the array for.
     * @param int    $lastToken  Stack pointer to the last token for the accumulated content.
     * @param bool   $isInt      Whether we know for sure this is not a float.
     *
     * @return array
     */
    private static function updateResult(array $result, $newContent, $lastToken, $isInt = false)
    {
        $result['orig_content'] = $newContent;
        $result['content']      = \str_replace('_', '', $newContent);
        $result['decimal']      = self::getDecimalValue($result['content']);
        $result['last_token']   = $lastToken;

        // Determine actual token type.
        $type = $result['type'];
        if ($type === 'T_LNUMBER') {
            if ($isInt === false
                && (\strpos($result['content'], '.') !== false
                || \stripos($result['content'], 'e') !== false)
            ) {
                $type = 'T_DNUMBER';
            } elseif (($result['decimal'] + 0) > \PHP_INT_MAX) {
                $type = 'T_DNUMBER';
            }
        }

        $result['code'] = \constant($type);
        $result['type'] = $type;

        return $result;
    }

    /**
     * Get the decimal number value of a numeric string.
     *
     * Takes PHP 7.4 numeric literal separators in numbers into account.
     *
     * @since 1.0.0
     *
     * @param string $textString Arbitrary text string.
     *                           This text string should be the (combined) token content of
     *                           one or more tokens which together represent a number in PHP.
     *
     * @return string|false Decimal number as a string or `FALSE` if the passed parameter
     *                      was not a numeric string.
     *                      > Note: floating point numbers with exponent will not be expanded,
     *                      but returned as-is.
     */
    public static function getDecimalValue($textString)
    {
        if (\is_string($textString) === false || $textString === '') {
            return false;
        }

        /*
         * Remove potential PHP 7.4 numeric literal separators.
         *
         * {@internal While the is..() functions also do this, this is still needed
         * here to allow the hexdec(), bindec() functions to work correctly and for
         * the decimal/float to return a cross-version compatible decimal value.}
         */
        $textString = \str_replace('_', '', $textString);

        if (self::isDecimalInt($textString) === true) {
            return $textString;
        }

        if (self::isHexidecimalInt($textString) === true) {
            return (string) \hexdec($textString);
        }

        if (self::isBinaryInt($textString) === true) {
            return (string) \bindec($textString);
        }

        if (self::isOctalInt($textString) === true) {
            return (string) \octdec($textString);
        }

        if (self::isFloat($textString) === true) {
            return $textString;
        }

        return false;
    }

    /**
     * Verify whether the contents of an arbitrary string represents a decimal integer.
     *
     * Takes PHP 7.4 numeric literal separators in numbers into account.
     *
     * @since 1.0.0
     *
     * @param string $textString Arbitrary string.
     *
     * @return bool
     */
    public static function isDecimalInt($textString)
    {
        if (\is_string($textString) === false || $textString === '') {
            return false;
        }

        // Remove potential PHP 7.4 numeric literal separators.
        $textString = \str_replace('_', '', $textString);

        return (\preg_match(self::REGEX_DECIMAL_INT, $textString) === 1);
    }

    /**
     * Verify whether the contents of an arbitrary string represents a hexidecimal integer.
     *
     * Takes PHP 7.4 numeric literal separators in numbers into account.
     *
     * @since 1.0.0
     *
     * @param string $textString Arbitrary string.
     *
     * @return bool
     */
    public static function isHexidecimalInt($textString)
    {
        if (\is_string($textString) === false || $textString === '') {
            return false;
        }

        // Remove potential PHP 7.4 numeric literal separators.
        $textString = \str_replace('_', '', $textString);

        return (\preg_match(self::REGEX_HEX_INT, $textString) === 1);
    }

    /**
     * Verify whether the contents of an arbitrary string represents a binary integer.
     *
     * Takes PHP 7.4 numeric literal separators in numbers into account.
     *
     * @since 1.0.0
     *
     * @param string $textString Arbitrary string.
     *
     * @return bool
     */
    public static function isBinaryInt($textString)
    {
        if (\is_string($textString) === false || $textString === '') {
            return false;
        }

        // Remove potential PHP 7.4 numeric literal separators.
        $textString = \str_replace('_', '', $textString);

        return (\preg_match(self::REGEX_BINARY_INT, $textString) === 1);
    }

    /**
     * Verify whether the contents of an arbitrary string represents an octal integer.
     *
     * Takes PHP 7.4 numeric literal separators in numbers into account.
     *
     * @since 1.0.0
     *
     * @param string $textString Arbitrary string.
     *
     * @return bool
     */
    public static function isOctalInt($textString)
    {
        if (\is_string($textString) === false || $textString === '') {
            return false;
        }

        // Remove potential PHP 7.4 numeric literal separators.
        $textString = \str_replace('_', '', $textString);

        return (\preg_match(self::REGEX_OCTAL_INT, $textString) === 1);
    }

    /**
     * Verify whether the contents of an arbitrary string represents a floating point number.
     *
     * Takes PHP 7.4 numeric literal separators in numbers into account.
     *
     * @since 1.0.0
     *
     * @param string $textString Arbitrary string.
     *
     * @return bool
     */
    public static function isFloat($textString)
    {
        if (\is_string($textString) === false || $textString === '') {
            return false;
        }

        // Remove potential PHP 7.4 numeric literal separators.
        $textString = \str_replace('_', '', $textString);

        return (\preg_match(self::REGEX_FLOAT, $textString) === 1);
    }
}

1	<?php
2	/**
3	* PHPCSUtils, utility functions and classes for PHP_CodeSniffer sniff developers.
4	*
5	* @package PHPCSUtils
6	* @copyright 2019-2020 PHPCSUtils Contributors
7	* @license https://opensource.org/licenses/LGPL-3.0 LGPL3
8	* @link https://github.com/PHPCSStandards/PHPCSUtils
9	*/
10
11	namespace PHPCSUtils\Utils;
12
13	use PHP_CodeSniffer\Exceptions\RuntimeException;
14	use PHP_CodeSniffer\Files\File;
15	use PHPCSUtils\BackCompat\Helper;
16
17	/**
18	* Utility functions for working with integer/float tokens.
19	*
20	* PHP 7.4 introduced numeric literal separators which break number tokenization in older PHP versions.
21	* PHPCS backfills this since PHPCS 3.5.3/4.
22	*
23	* Along the same lines, PHP 8.1 introduced an explicit octal notation which also breaks number tokenization
24	* in older PHP versions. This is backfilled in PHPCS since PHPCS 3.7.0.
25	*
26	* In other words, if an external standard intends to support PHPCS < 3.7.0 and PHP < 8.1, working
27	* with number tokens has suddenly become a challenge.
28	*
29	* The functions in this class have been put in place to ease that pain and it is
30	* strongly recommended to always use these functions when sniffing for and examining the
31	* contents of `T_LNUMBER` or `T_DNUMBER` tokens.
32	*
33	* @link https://www.php.net/migration74.new-features.php#migration74.new-features.core.numeric-literal-separator
34	* PHP Manual on numeric literal separators.
35	* @link https://www.php.net/manual/en/migration81.new-features.php#migration81.new-features.core.octal-literal-prefix
36	* PHP Manual on the introduction of the integer octal literal prefix.
37	*
38	* @since 1.0.0
39	*/
40	class Numbers
41	{
42
43	/**
44	* Regex to determine whether the contents of an arbitrary string represents a decimal integer.
45	*
46	* @since 1.0.0
47	*
48	* @var string
49	*/
50	const REGEX_DECIMAL_INT = '`^(?:0\|[1-9][0-9]*)$`D';
51
52	/**
53	* Regex to determine whether the contents of an arbitrary string represents an octal integer.
54	*
55	* @since 1.0.0
56	*
57	* @var string
58	*/
59	const REGEX_OCTAL_INT = '`^0[o]?[0-7]+$`iD';
60
61	/**
62	* Regex to determine whether the contents of an arbitrary string represents a binary integer.
63	*
64	* @since 1.0.0
65	*
66	* @var string
67	*/
68	const REGEX_BINARY_INT = '`^0b[0-1]+$`iD';
69
70	/**
71	* Regex to determine whether the contents of an arbitrary string represents a hexidecimal integer.
72	*
73	* @since 1.0.0
74	*
75	* @var string
76	*/
77	const REGEX_HEX_INT = '`^0x[0-9A-F]+$`iD';
78
79	/**
80	* Regex to determine whether the contents of an arbitrary string represents a float.
81	*
82	* @link https://www.php.net/language.types.float PHP Manual on floats
83	*
84	* @since 1.0.0
85	*
86	* @var string
87	*/
88	const REGEX_FLOAT = '`
89	^(?:
90	(?:
91	(?:
92	(?P<LNUM>[0-9]+)
93	\|
94	(?P<DNUM>([0-9]\.(?P>LNUM)\|(?P>LNUM)\.[0-9]))
95	)
96	[e][+-]?(?P>LNUM)
97	)
98	\|
99	(?P>DNUM)
100	\|
101	(?:0\|[1-9][0-9]*)
102	)$
103	`ixD';
104
105	/**
106	* Regex to determine if a T_STRING following a T_[DL]NUMBER is part of a numeric literal sequence.
107	*
108	* Cross-version compatibility helper for PHP 7.4 numeric literals with underscore separators.
109	*
110	* @since 1.0.0
111	*
112	* @var string
113	*/
114	const REGEX_NUMLIT_STRING = '`^((?<![\.e])_[0-9][0-9e\.]*)+$`iD';
115
116	/**
117	* Regex to determine is a T_STRING following a T_[DL]NUMBER is part of a hexidecimal numeric literal sequence.
118	*
119	* Cross-version compatibility helper for PHP 7.4 numeric literals with underscore separators.
120	*
121	* @since 1.0.0
122	*
123	* @var string
124	*/
125	const REGEX_HEX_NUMLIT_STRING = '`^((?<!\.)_[0-9A-F]*)+$`iD';
126
127	/**
128	* PHPCS versions in which the backfill for PHP 7.4 numeric literal separators is broken.
129	*
130	* @since 1.0.0
131	* @since 1.0.0-alpha2 Changed from a property to a class constant.
132	* Changed from an array to a string.
133	*
134	* @var string
135	*/
136	const UNSUPPORTED_PHPCS_VERSION = '3.5.3';
137
138	/**
139	* Valid tokens which could be part of a numeric literal sequence in PHP < 7.4.
140	*
141	* @since 1.0.0
142	*
143	* @var array
144	*/
145	private static $numericLiteralAcceptedTokens = [
146	\T_LNUMBER => true,
147	\T_DNUMBER => true,
148	\T_STRING => true,
149	];
150
151	/**
152	* Retrieve information about a number token in a cross-version compatible manner.
153	*
154	* Helper function to deal with numeric literals, potentially with underscore separators
155	* and/or explicit octal notation.
156	*
157	* PHP < 7.4 does not tokenize numeric literals containing underscores correctly.
158	* As of PHPCS 3.5.3, PHPCS contains a backfill, but this backfill was buggy in the initial
159	* implementation. A fix for this broken backfill is included in PHPCS 3.5.4.
160	*
161	* PHP < 8.1 does not tokenize explicit octal notation for literal integers correctly.
162	* PHPCS backfills this as of PHPCS 3.7.0.
163	*
164	* Either way, this function can be used with all PHPCS/PHP combinations and will, if necessary,
165	* provide a backfill for PHPCS/PHP combinations where PHP 7.4 numbers with underscore separators
166	* and/or octals using the explicit octal prefix, are tokenized incorrectly - with the exception
167	* of PHPCS 3.5.3 as the buggyness of the original backfill implementation makes it impossible
168	* to provide reliable results.
169	*
170	* @link https://github.com/squizlabs/PHP_CodeSniffer/issues/2546 PHPCS issue #2546
171	* @link https://github.com/squizlabs/PHP_CodeSniffer/pull/2771 PHPCS PR #2771
172	* @link https://github.com/squizlabs/PHP_CodeSniffer/pull/3481 PHPCS PR #3481
173	* @link https://github.com/squizlabs/PHP_CodeSniffer/pull/3552 PHPCS PR #3552
174	*
175	* @since 1.0.0
176	*
177	* @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
178	* @param int $stackPtr The position of a T_LNUMBER or T_DNUMBER token.
179	*
180	* @return array An array with information about the number.
181	* The format of the array return value is:
182	* ```php
183	* array(
184	* 'orig_content' => string, // The (potentially concatenated) original
185	* // content of the tokens;
186	* 'content' => string, // The (potentially concatenated) content,
187	* // underscore(s) removed;
188	* 'code' => int, // The token code of the number, either
189	* // T_LNUMBER or T_DNUMBER.
190	* 'type' => string, // The token type, either 'T_LNUMBER'
191	* // or 'T_DNUMBER'.
192	* 'decimal' => string, // The decimal value of the number;
193	* 'last_token' => int, // The stackPtr to the last token which was
194	* // part of the number.
195	* // This will be the same as the original
196	* // stackPtr if it is not a PHP 7.4 number
197	* // with underscores.
198	* )
199	* ```
200	*
201	* @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified token is not of type
202	* `T_LNUMBER` or `T_DNUMBER`.
203	* @throws \PHP_CodeSniffer\Exceptions\RuntimeException If this function is called in combination
204	* with an unsupported PHPCS version.
205	*/
206	public static function getCompleteNumber(File $phpcsFile, $stackPtr)
207	{
208	static $php74, $php81, $phpcsVersion, $phpcsWithBackfill, $phpcsWithOctalSupport;	148✔
209
210	$tokens = $phpcsFile->getTokens();	148✔
211
212	if (isset($tokens[$stackPtr]) === false	148✔
213	\|\| ($tokens[$stackPtr]['code'] !== \T_LNUMBER && $tokens[$stackPtr]['code'] !== \T_DNUMBER)	148✔
214	) {	74✔
215	throw new RuntimeException(	4✔
216	'Token type "' . $tokens[$stackPtr]['type'] . '" is not T_LNUMBER or T_DNUMBER'	4✔
217	);	2✔
218	}
219
220	if (isset($php74, $php81, $phpcsVersion, $phpcsWithBackfill, $phpcsWithOctalSupport) === false) {	144✔
NEW 221	$php74 = \version_compare(\PHP_VERSION_ID, '70399', '>');	×
NEW 222	$php81 = \version_compare(\PHP_VERSION_ID, '80099', '>');	×
NEW 223	$phpcsVersion = Helper::getVersion();	×
NEW 224	$phpcsWithBackfill = \version_compare($phpcsVersion, self::UNSUPPORTED_PHPCS_VERSION, '>');	×
NEW 225	$phpcsWithOctalSupport = \version_compare($phpcsVersion, '3.7.0', '>=');	×
226	}
227
228	/*
229	* Bow out for PHPCS version(s) with broken tokenization of PHP 7.4 numeric literals with
230	* separators, including for PHP 7.4, as the backfill kicks in for PHP 7.4 while it shouldn't.
231	*
232	* @link https://github.com/squizlabs/PHP_CodeSniffer/issues/2546
233	*/
234	if (\version_compare($phpcsVersion, self::UNSUPPORTED_PHPCS_VERSION, '==') === true) {	144✔
235	throw new RuntimeException('The ' . __METHOD__ . '() method does not support PHPCS ' . $phpcsVersion);	×
236	}
237
238	$content = $tokens[$stackPtr]['content'];	144✔
239	$result = [
240	'orig_content' => $content,	144✔
241	'content' => \str_replace('_', '', $content),	144✔
242	'code' => $tokens[$stackPtr]['code'],	144✔
243	'type' => $tokens[$stackPtr]['type'],	144✔
244	'decimal' => self::getDecimalValue($content),	144✔
245	'last_token' => $stackPtr,	144✔
246	];	72✔
247
248	/*
249	* When things are already correctly tokenized for both situations handled by this method,
250	* there's not much to do.
251	*/
252	if ($php81 === true \|\| $phpcsWithOctalSupport === true) {	144✔
253	return $result;	72✔
254	}
255
256	/*
257	* Potentially handle explicit octal notation.
258	*/
259	if (isset($tokens[($stackPtr + 1)]) === true	72✔
260	&& $tokens[($stackPtr + 1)]['code'] === \T_STRING	72✔
261	&& \strtolower($tokens[($stackPtr + 1)]['content'][0]) === 'o'	72✔
262	&& $tokens[($stackPtr + 1)]['content'][1] !== '_'	72✔
263	) {	36✔
264	$content .= $tokens[($stackPtr + 1)]['content'];	6✔
265	$result = self::updateResult($result, $content, ($stackPtr + 1), true);	6✔
266	}	3✔
267
268	/*
269	* Check if numeric literal notation needs handling.
270	*/
271	if ($php74 === true	36✔
272	\|\| $phpcsWithBackfill === true	72✔
273	\|\| isset($tokens[($result['last_token'] + 1)]) === false	72✔
274	\|\| $tokens[($result['last_token'] + 1)]['code'] !== \T_STRING	72✔
275	\|\| $tokens[($result['last_token'] + 1)]['content'][0] !== '_'	72✔
276	) {	36✔
277	return $result;	30✔
278	}
279
280	$hex = false;	42✔
281	if (\strpos($content, '0x') === 0) {	42✔
282	$hex = true;	2✔
283	}	1✔
284
285	$lastChar = \substr($content, -1);	42✔
286	if (\preg_match('`[0-9]`', $lastChar) !== 1) {	42✔
287	if ($hex === false \|\| \preg_match('`[A-F]`i', $lastChar) !== 1) {	4✔
288	// Last character not valid for numeric literal sequence with underscores.
289	// No need to look any further.
290	return $result;	2✔
291	}
292	}	1✔
293
294	/*
295	* OK, so this could potentially be a PHP 7.4 number with an underscore separator with PHPCS
296	* being run on PHP < 7.4.
297	*/
298
299	$regex = self::REGEX_NUMLIT_STRING;	40✔
300	if ($hex === true) {	40✔
301	$regex = self::REGEX_HEX_NUMLIT_STRING;	2✔
302	}	1✔
303
304	$next = $result['last_token'];	40✔
305	$lastToken = $result['last_token'];	40✔
306
307	while (isset($tokens[++$next], self::$numericLiteralAcceptedTokens[$tokens[$next]['code']]) === true) {	40✔
308	if ($tokens[$next]['code'] === \T_STRING	40✔
309	&& \preg_match($regex, $tokens[$next]['content']) !== 1	40✔
310	) {	20✔
311	break;	8✔
312	}
313
314	$content .= $tokens[$next]['content'];	32✔
315	$lastToken = $next;	32✔
316	$lastChar = \substr(\strtolower($content), -1);	32✔
317
318	// Support floats.
319	if ($lastChar === 'e'	16✔
320	&& isset($tokens[($next + 1)], $tokens[($next + 2)]) === true	32✔
321	&& ($tokens[($next + 1)]['code'] === \T_MINUS	18✔
322	\|\| $tokens[($next + 1)]['code'] === \T_PLUS)	18✔
323	&& $tokens[($next + 2)]['code'] === \T_LNUMBER	32✔
324	) {	16✔
325	$content .= $tokens[($next + 1)]['content'];	4✔
326	$content .= $tokens[($next + 2)]['content'];	4✔
327	$next += 2;	4✔
328	$lastToken = $next;	4✔
329	}	2✔
330
331	// Don't look any further if the last char is not valid before a separator.
332	if (\preg_match('`[0-9]`', $lastChar) !== 1) {	32✔
333	if ($hex === false \|\| \preg_match('`[a-f]`i', $lastChar) !== 1) {	6✔
334	break;	4✔
335	}
336	}	1✔
337	}	14✔
338
339	return self::updateResult($result, $content, $lastToken, $hex);	40✔
340	}
341
342	/**
343	* Helper function to update the result array for the getCompleteNumber() method.
344	*
345	* @param array $result Current result array.
346	* @param string $newContent The new content for the number to update the array for.
347	* @param int $lastToken Stack pointer to the last token for the accumulated content.
348	* @param bool $isInt Whether we know for sure this is not a float.
349	*
350	* @return array
351	*/
352	private static function updateResult(array $result, $newContent, $lastToken, $isInt = false)
353	{
NEW 354	$result['orig_content'] = $newContent;	×
NEW 355	$result['content'] = \str_replace('_', '', $newContent);	×
356	$result['decimal'] = self::getDecimalValue($result['content']);	×
357	$result['last_token'] = $lastToken;	×
358
359	// Determine actual token type.
360	$type = $result['type'];	×
361	if ($type === 'T_LNUMBER') {	×
362	if ($isInt === false
363	&& (\strpos($result['content'], '.') !== false	×
364	\|\| \stripos($result['content'], 'e') !== false)	×
365	) {
366	$type = 'T_DNUMBER';	×
367	} elseif (($result['decimal'] + 0) > \PHP_INT_MAX) {	×
368	$type = 'T_DNUMBER';	×
369	}
370	}
371
372	$result['code'] = \constant($type);	×
373	$result['type'] = $type;	×
374
375	return $result;	×
376	}
377
378	/**
379	* Get the decimal number value of a numeric string.
380	*
381	* Takes PHP 7.4 numeric literal separators in numbers into account.
382	*
383	* @since 1.0.0
384	*
385	* @param string $textString Arbitrary text string.
386	* This text string should be the (combined) token content of
387	* one or more tokens which together represent a number in PHP.
388	*
389	* @return string\|false Decimal number as a string or `FALSE` if the passed parameter
390	* was not a numeric string.
391	* > Note: floating point numbers with exponent will not be expanded,
392	* but returned as-is.
393	*/
394	public static function getDecimalValue($textString)
395	{
396	if (\is_string($textString) === false \|\| $textString === '') {	128✔
397	return false;	16✔
398	}
399
400	/*
401	* Remove potential PHP 7.4 numeric literal separators.
402	*
403	* {@internal While the is..() functions also do this, this is still needed
404	* here to allow the hexdec(), bindec() functions to work correctly and for
405	* the decimal/float to return a cross-version compatible decimal value.}
406	*/
407	$textString = \str_replace('_', '', $textString);	112✔
408
409	if (self::isDecimalInt($textString) === true) {	112✔
410	return $textString;	16✔
411	}
412
413	if (self::isHexidecimalInt($textString) === true) {	96✔
414	return (string) \hexdec($textString);	16✔
415	}
416
417	if (self::isBinaryInt($textString) === true) {	80✔
418	return (string) \bindec($textString);	12✔
419	}
420
421	if (self::isOctalInt($textString) === true) {	68✔
422	return (string) \octdec($textString);	24✔
423	}
424
425	if (self::isFloat($textString) === true) {	44✔
426	return $textString;	20✔
427	}
428
429	return false;	24✔
430	}
431
432	/**
433	* Verify whether the contents of an arbitrary string represents a decimal integer.
434	*
435	* Takes PHP 7.4 numeric literal separators in numbers into account.
436	*
437	* @since 1.0.0
438	*
439	* @param string $textString Arbitrary string.
440	*
441	* @return bool
442	*/
443	public static function isDecimalInt($textString)
444	{
445	if (\is_string($textString) === false \|\| $textString === '') {	304✔
446	return false;	12✔
447	}
448
449	// Remove potential PHP 7.4 numeric literal separators.
450	$textString = \str_replace('_', '', $textString);	292✔
451
452	return (\preg_match(self::REGEX_DECIMAL_INT, $textString) === 1);	292✔
453	}
454
455	/**
456	* Verify whether the contents of an arbitrary string represents a hexidecimal integer.
457	*
458	* Takes PHP 7.4 numeric literal separators in numbers into account.
459	*
460	* @since 1.0.0
461	*
462	* @param string $textString Arbitrary string.
463	*
464	* @return bool
465	*/
466	public static function isHexidecimalInt($textString)
467	{
468	if (\is_string($textString) === false \|\| $textString === '') {	304✔
469	return false;	12✔
470	}
471
472	// Remove potential PHP 7.4 numeric literal separators.
473	$textString = \str_replace('_', '', $textString);	292✔
474
475	return (\preg_match(self::REGEX_HEX_INT, $textString) === 1);	292✔
476	}
477
478	/**
479	* Verify whether the contents of an arbitrary string represents a binary integer.
480	*
481	* Takes PHP 7.4 numeric literal separators in numbers into account.
482	*
483	* @since 1.0.0
484	*
485	* @param string $textString Arbitrary string.
486	*
487	* @return bool
488	*/
489	public static function isBinaryInt($textString)
490	{
491	if (\is_string($textString) === false \|\| $textString === '') {	304✔
492	return false;	12✔
493	}
494
495	// Remove potential PHP 7.4 numeric literal separators.
496	$textString = \str_replace('_', '', $textString);	292✔
497
498	return (\preg_match(self::REGEX_BINARY_INT, $textString) === 1);	292✔
499	}
500
501	/**
502	* Verify whether the contents of an arbitrary string represents an octal integer.
503	*
504	* Takes PHP 7.4 numeric literal separators in numbers into account.
505	*
506	* @since 1.0.0
507	*
508	* @param string $textString Arbitrary string.
509	*
510	* @return bool
511	*/
512	public static function isOctalInt($textString)
513	{
514	if (\is_string($textString) === false \|\| $textString === '') {	304✔
515	return false;	12✔
516	}
517
518	// Remove potential PHP 7.4 numeric literal separators.
519	$textString = \str_replace('_', '', $textString);	292✔
520
521	return (\preg_match(self::REGEX_OCTAL_INT, $textString) === 1);	292✔
522	}
523
524	/**
525	* Verify whether the contents of an arbitrary string represents a floating point number.
526	*
527	* Takes PHP 7.4 numeric literal separators in numbers into account.
528	*
529	* @since 1.0.0
530	*
531	* @param string $textString Arbitrary string.
532	*
533	* @return bool
534	*/
535	public static function isFloat($textString)
536	{
537	if (\is_string($textString) === false \|\| $textString === '') {	304✔
538	return false;	12✔
539	}
540
541	// Remove potential PHP 7.4 numeric literal separators.
542	$textString = \str_replace('_', '', $textString);	292✔
543
544	return (\preg_match(self::REGEX_FLOAT, $textString) === 1);	292✔
545	}
546	}

PHPCSStandards / PHPCSUtils / 1908500122

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous