1698

pending completion

Build # 1698

Build Type

Pull #632

travis-ci

Committed by

web-flow

Commit Message

:sparkles: PHP 7.3: new sniff to detect trailing comma's in function calls, isset() and unset()

Trailing comma's in function calls, method calls, `isset()` and `unset()` will be allowed as of PHP 7.3.

Refs:
* https://wiki.php.net/rfc/trailing-comma-function-calls
* https://github.com/php/php-src/commit/b591c329e

I've kept the name of the sniff relatively generic to allow for adding more constructs in the future in case trailing comma's will start to be allowed in, for instance, `list()`.

Includes unit tests which are largely based on the example code in the RFC/unit tests in PHP core.

Pull Request Pull Request #632: PHP 7.3: new sniff to detect trailing comma's in function calls, isset() and unset()

Run Details

45 of 45 new or added lines in 1 file covered. (100.0%)

2984 of 3093 relevant lines covered (96.48%)

31.06 hits per line

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

98.28

/PHPCompatibility/Sniffs/PHP/NewNullableTypesSniff.php

<?php
/**
 * \PHPCompatibility\Sniffs\PHP\NewNullableTypes.
 *
 * PHP version 7.1
 *
 * @category PHP
 * @package  PHPCompatibility
 * @author   Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
 */

namespace PHPCompatibility\Sniffs\PHP;

use PHPCompatibility\Sniff;
use PHPCompatibility\PHPCSHelper;

/**
 * \PHPCompatibility\Sniffs\PHP\NewNullableTypes.
 *
 * Nullable type hints and return types are available since PHP 7.1.
 *
 * PHP version 7.1
 *
 * @category PHP
 * @package  PHPCompatibility
 * @author   Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
 */
class NewNullableTypesSniff extends Sniff
{
    /**
     * Returns an array of tokens this test wants to listen for.
     *
     * {@internal Not sniffing for T_NULLABLE which was introduced in PHPCS 2.7.2
     * as in that case we can't distinguish between parameter type hints and
     * return type hints for the error message.}}
     *
     * @return array
     */
    public function register()
    {
        $tokens = array(
            T_FUNCTION,
            T_CLOSURE,
        );

        if (defined('T_RETURN_TYPE')) {
            $tokens[] = T_RETURN_TYPE;
        }

        return $tokens;

    }//end register()


    /**
     * Processes this test, when one of its tokens is encountered.
     *
     * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                   $stackPtr  The position of the current token
     *                                         in the stack passed in $tokens.
     *
     * @return void
     */
    public function process(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        if ($this->supportsBelow('7.0') === false) {
            return;
        }

        $tokens    = $phpcsFile->getTokens();
        $tokenCode = $tokens[$stackPtr]['code'];

        if ($tokenCode === T_FUNCTION || $tokenCode === T_CLOSURE) {
            $this->processFunctionDeclaration($phpcsFile, $stackPtr);

            // Deal with older PHPCS version which don't recognize return type hints
            // as well as newer PHPCS versions (3.3.0+) where the tokenization has changed.
            $returnTypeHint = $this->getReturnTypeHintToken($phpcsFile, $stackPtr);
            if ($returnTypeHint !== false) {
                $this->processReturnType($phpcsFile, $returnTypeHint);
            }
        } else {
            $this->processReturnType($phpcsFile, $stackPtr);
        }

    }//end process()


    /**
     * Process this test for function tokens.
     *
     * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                   $stackPtr  The position of the current token
     *                                         in the stack passed in $tokens.
     *
     * @return void
     */
    protected function processFunctionDeclaration(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        $params = PHPCSHelper::getMethodParameters($phpcsFile, $stackPtr);

        if (empty($params) === false && is_array($params)) {
            foreach ($params as $param) {
                if ($param['nullable_type'] === true) {
                    $phpcsFile->addError(
                        'Nullable type declarations are not supported in PHP 7.0 or earlier. Found: %s',
                        $param['token'],
                        'typeDeclarationFound',
                        array($param['type_hint'])
                    );
                }
            }
        }
    }


    /**
     * Process this test for return type tokens.
     *
     * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                   $stackPtr  The position of the current token
     *                                         in the stack passed in $tokens.
     *
     * @return void
     */
    protected function processReturnType(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        $tokens = $phpcsFile->getTokens();

        if (isset($tokens[($stackPtr - 1)]['code']) === false) {
            return;
        }

        $previous = $phpcsFile->findPrevious(\PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);

        // Deal with namespaced class names.
        if ($tokens[$previous]['code'] === T_NS_SEPARATOR) {
            $validTokens   = \PHP_CodeSniffer_Tokens::$emptyTokens;
            $validTokens[] = T_STRING;
            $validTokens[] = T_NS_SEPARATOR;

            $stackPtr--;

            while (in_array($tokens[($stackPtr - 1)]['code'], $validTokens, true) === true) {
                $stackPtr--;
            }

            $previous = $phpcsFile->findPrevious(\PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);
        }

        // T_NULLABLE token was introduced in PHPCS 2.7.2. Before that it identified as T_INLINE_THEN.
        if ((defined('T_NULLABLE') === true && $tokens[$previous]['type'] === 'T_NULLABLE')
            || (defined('T_NULLABLE') === false && $tokens[$previous]['code'] === T_INLINE_THEN)
        ) {
            $phpcsFile->addError(
                'Nullable return types are not supported in PHP 7.0 or earlier.',
                $stackPtr,
                'returnTypeFound'
            );
        }
    }

}//end class

1	<?php
2	/**
3	* \PHPCompatibility\Sniffs\PHP\NewNullableTypes.
4	*
5	* PHP version 7.1
6	*
7	* @category PHP
8	* @package PHPCompatibility
9	* @author Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
10	*/
11
12	namespace PHPCompatibility\Sniffs\PHP;
13
14	use PHPCompatibility\Sniff;
15	use PHPCompatibility\PHPCSHelper;
16
17	/**
18	* \PHPCompatibility\Sniffs\PHP\NewNullableTypes.
19	*
20	* Nullable type hints and return types are available since PHP 7.1.
21	*
22	* PHP version 7.1
23	*
24	* @category PHP
25	* @package PHPCompatibility
26	* @author Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
27	*/
28	class NewNullableTypesSniff extends Sniff
29	{
30	/**
31	* Returns an array of tokens this test wants to listen for.
32	*
33	* {@internal Not sniffing for T_NULLABLE which was introduced in PHPCS 2.7.2
34	* as in that case we can't distinguish between parameter type hints and
35	* return type hints for the error message.}}
36	*
37	* @return array
38	*/
39	public function register()
40	{
41	$tokens = array(
42	T_FUNCTION,	176✔
43	T_CLOSURE,	176✔
44	);	88✔
45
46	if (defined('T_RETURN_TYPE')) {	176✔
47	$tokens[] = T_RETURN_TYPE;	47✔
48	}	45✔
49
50	return $tokens;	176✔
51
52	}//end register()
53
54
55	/**
56	* Processes this test, when one of its tokens is encountered.
57	*
58	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
59	* @param int $stackPtr The position of the current token
60	* in the stack passed in $tokens.
61	*
62	* @return void
63	*/
64	public function process(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
65	{
66	if ($this->supportsBelow('7.0') === false) {	12✔
67	return;	6✔
68	}
69
70	$tokens = $phpcsFile->getTokens();	6✔
71	$tokenCode = $tokens[$stackPtr]['code'];	6✔
72
73	if ($tokenCode === T_FUNCTION \|\| $tokenCode === T_CLOSURE) {	6✔
74	$this->processFunctionDeclaration($phpcsFile, $stackPtr);	6✔
75
76	// Deal with older PHPCS version which don't recognize return type hints
77	// as well as newer PHPCS versions (3.3.0+) where the tokenization has changed.
78	$returnTypeHint = $this->getReturnTypeHintToken($phpcsFile, $stackPtr);	6✔
79	if ($returnTypeHint !== false) {	6✔
80	$this->processReturnType($phpcsFile, $returnTypeHint);	6✔
81	}	3✔
82	} else {	3✔
83	$this->processReturnType($phpcsFile, $stackPtr);	1✔
84	}
85
86	}//end process()	6✔
87
88
89	/**
90	* Process this test for function tokens.
91	*
92	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
93	* @param int $stackPtr The position of the current token
94	* in the stack passed in $tokens.
95	*
96	* @return void
97	*/
98	protected function processFunctionDeclaration(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
99	{
100	$params = PHPCSHelper::getMethodParameters($phpcsFile, $stackPtr);	6✔
101
102	if (empty($params) === false && is_array($params)) {	6✔
103	foreach ($params as $param) {	6✔
104	if ($param['nullable_type'] === true) {	6✔
105	$phpcsFile->addError(	6✔
106	'Nullable type declarations are not supported in PHP 7.0 or earlier. Found: %s',	6✔
107	$param['token'],	6✔
108	'typeDeclarationFound',	6✔
109	array($param['type_hint'])	6✔
110	);	3✔
111	}	3✔
112	}	3✔
113	}	3✔
114	}	6✔
115
116
117	/**
118	* Process this test for return type tokens.
119	*
120	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
121	* @param int $stackPtr The position of the current token
122	* in the stack passed in $tokens.
123	*
124	* @return void
125	*/
126	protected function processReturnType(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
127	{
128	$tokens = $phpcsFile->getTokens();	6✔
129
130	if (isset($tokens[($stackPtr - 1)]['code']) === false) {	6✔
131	return;	×
132	}
133
134	$previous = $phpcsFile->findPrevious(\PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);	6✔
135
136	// Deal with namespaced class names.
137	if ($tokens[$previous]['code'] === T_NS_SEPARATOR) {	6✔
138	$validTokens = \PHP_CodeSniffer_Tokens::$emptyTokens;	6✔
139	$validTokens[] = T_STRING;	6✔
140	$validTokens[] = T_NS_SEPARATOR;	6✔
141
142	$stackPtr--;	6✔
143
144	while (in_array($tokens[($stackPtr - 1)]['code'], $validTokens, true) === true) {	6✔
145	$stackPtr--;	6✔
146	}	3✔
147
148	$previous = $phpcsFile->findPrevious(\PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);	6✔
149	}	3✔
150
151	// T_NULLABLE token was introduced in PHPCS 2.7.2. Before that it identified as T_INLINE_THEN.
152	if ((defined('T_NULLABLE') === true && $tokens[$previous]['type'] === 'T_NULLABLE')	6✔
153	\|\| (defined('T_NULLABLE') === false && $tokens[$previous]['code'] === T_INLINE_THEN)	6✔
154	) {	3✔
155	$phpcsFile->addError(	6✔
156	'Nullable return types are not supported in PHP 7.0 or earlier.',	6✔
157	$stackPtr,	6✔
158	'returnTypeFound'	3✔
159	);	3✔
160	}	3✔
161	}	6✔
162
163	}//end class

PHPCompatibility / PHPCompatibility / 1698

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