gravityview / GravityView

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/Keywords/NewKeywordsSniff.php

Indentation +323 added lines, -323 removed lines

@@ -25,196 +25,196 @@ 
 class NewKeywordsSniff extends AbstractNewFeatureSniff
 {
 
-    /**
-     * A list of new keywords, not present in older versions.
-     *
-     * The array lists : version number with false (not present) or true (present).
-     * If's sufficient to list the last version which did not contain the keyword.
-     *
-     * Description will be used as part of the error message.
-     * Condition is the name of a callback method within this class or the parent class
-     * which checks whether the token complies with a certain condition.
-     * The callback function will be passed the $phpcsFile and the $stackPtr.
-     * The callback function should return `true` if the condition is met and the
-     * error should *not* be thrown.
-     *
-     * @var array(string => array(string => int|string|null))
-     */
-    protected $newKeywords = array(
-        'T_HALT_COMPILER' => array(
-            '5.0'         => false,
-            '5.1'         => true,
-            'description' => '"__halt_compiler" keyword',
-        ),
-        'T_CONST' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '"const" keyword',
-            'condition'   => 'isClassConstant', // Keyword is only new when not in class context.
-        ),
-        'T_CALLABLE' => array(
-            '5.3'         => false,
-            '5.4'         => true,
-            'description' => '"callable" keyword',
-            'content'     => 'callable',
-        ),
-        'T_DIR' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '__DIR__ magic constant',
-            'content'     => '__DIR__',
-        ),
-        'T_GOTO' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '"goto" keyword',
-            'content'     => 'goto',
-        ),
-        'T_INSTEADOF' => array(
-            '5.3'         => false,
-            '5.4'         => true,
-            'description' => '"insteadof" keyword (for traits)',
-            'content'     => 'insteadof',
-        ),
-        'T_NAMESPACE' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '"namespace" keyword',
-            'content'     => 'namespace',
-        ),
-        'T_NS_C' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '__NAMESPACE__ magic constant',
-            'content'     => '__NAMESPACE__',
-        ),
-        'T_USE' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '"use" keyword (for traits/namespaces/anonymous functions)',
-        ),
-        'T_START_NOWDOC' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => 'nowdoc functionality',
-        ),
-        'T_END_NOWDOC' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => 'nowdoc functionality',
-        ),
-        'T_START_HEREDOC' => array(
-            '5.2'         => false,
-            '5.3'         => true,
-            'description' => '(Double) quoted Heredoc identifier',
-            'condition'   => 'isNotQuoted', // Heredoc is only new with quoted identifier.
-        ),
-        'T_TRAIT' => array(
-            '5.3'         => false,
-            '5.4'         => true,
-            'description' => '"trait" keyword',
-            'content'     => 'trait',
-        ),
-        'T_TRAIT_C' => array(
-            '5.3'         => false,
-            '5.4'         => true,
-            'description' => '__TRAIT__ magic constant',
-            'content'     => '__TRAIT__',
-        ),
-        // The specifics for distinguishing between 'yield' and 'yield from' are dealt
-        // with in the translation logic.
-        // This token has to be placed above the `T_YIELD` token in this array to allow for this.
-        'T_YIELD_FROM' => array(
-            '5.6'         => false,
-            '7.0'         => true,
-            'description' => '"yield from" keyword (for generators)',
-            'content'     => 'yield',
-        ),
-        'T_YIELD' => array(
-            '5.4'         => false,
-            '5.5'         => true,
-            'description' => '"yield" keyword (for generators)',
-            'content'     => 'yield',
-        ),
-        'T_FINALLY' => array(
-            '5.4'         => false,
-            '5.5'         => true,
-            'description' => '"finally" keyword (in exception handling)',
-            'content'     => 'finally',
-        ),
-    );
-
-    /**
-     * Translation table for T_STRING tokens.
-     *
-     * Will be set up from the register() method.
-     *
-     * @var array(string => string)
-     */
-    protected $translateContentToToken = array();
-
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        $tokens    = array();
-        $translate = array();
-        foreach ($this->newKeywords as $token => $versions) {
-            if (\defined($token)) {
-                $tokens[] = constant($token);
-            }
-            if (isset($versions['content'])) {
-                $translate[strtolower($versions['content'])] = $token;
-            }
-        }
-
-        /*
+	/**
+	 * A list of new keywords, not present in older versions.
+	 *
+	 * The array lists : version number with false (not present) or true (present).
+	 * If's sufficient to list the last version which did not contain the keyword.
+	 *
+	 * Description will be used as part of the error message.
+	 * Condition is the name of a callback method within this class or the parent class
+	 * which checks whether the token complies with a certain condition.
+	 * The callback function will be passed the $phpcsFile and the $stackPtr.
+	 * The callback function should return `true` if the condition is met and the
+	 * error should *not* be thrown.
+	 *
+	 * @var array(string => array(string => int|string|null))
+	 */
+	protected $newKeywords = array(
+		'T_HALT_COMPILER' => array(
+			'5.0'         => false,
+			'5.1'         => true,
+			'description' => '"__halt_compiler" keyword',
+		),
+		'T_CONST' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '"const" keyword',
+			'condition'   => 'isClassConstant', // Keyword is only new when not in class context.
+		),
+		'T_CALLABLE' => array(
+			'5.3'         => false,
+			'5.4'         => true,
+			'description' => '"callable" keyword',
+			'content'     => 'callable',
+		),
+		'T_DIR' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '__DIR__ magic constant',
+			'content'     => '__DIR__',
+		),
+		'T_GOTO' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '"goto" keyword',
+			'content'     => 'goto',
+		),
+		'T_INSTEADOF' => array(
+			'5.3'         => false,
+			'5.4'         => true,
+			'description' => '"insteadof" keyword (for traits)',
+			'content'     => 'insteadof',
+		),
+		'T_NAMESPACE' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '"namespace" keyword',
+			'content'     => 'namespace',
+		),
+		'T_NS_C' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '__NAMESPACE__ magic constant',
+			'content'     => '__NAMESPACE__',
+		),
+		'T_USE' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '"use" keyword (for traits/namespaces/anonymous functions)',
+		),
+		'T_START_NOWDOC' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => 'nowdoc functionality',
+		),
+		'T_END_NOWDOC' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => 'nowdoc functionality',
+		),
+		'T_START_HEREDOC' => array(
+			'5.2'         => false,
+			'5.3'         => true,
+			'description' => '(Double) quoted Heredoc identifier',
+			'condition'   => 'isNotQuoted', // Heredoc is only new with quoted identifier.
+		),
+		'T_TRAIT' => array(
+			'5.3'         => false,
+			'5.4'         => true,
+			'description' => '"trait" keyword',
+			'content'     => 'trait',
+		),
+		'T_TRAIT_C' => array(
+			'5.3'         => false,
+			'5.4'         => true,
+			'description' => '__TRAIT__ magic constant',
+			'content'     => '__TRAIT__',
+		),
+		// The specifics for distinguishing between 'yield' and 'yield from' are dealt
+		// with in the translation logic.
+		// This token has to be placed above the `T_YIELD` token in this array to allow for this.
+		'T_YIELD_FROM' => array(
+			'5.6'         => false,
+			'7.0'         => true,
+			'description' => '"yield from" keyword (for generators)',
+			'content'     => 'yield',
+		),
+		'T_YIELD' => array(
+			'5.4'         => false,
+			'5.5'         => true,
+			'description' => '"yield" keyword (for generators)',
+			'content'     => 'yield',
+		),
+		'T_FINALLY' => array(
+			'5.4'         => false,
+			'5.5'         => true,
+			'description' => '"finally" keyword (in exception handling)',
+			'content'     => 'finally',
+		),
+	);
+
+	/**
+	 * Translation table for T_STRING tokens.
+	 *
+	 * Will be set up from the register() method.
+	 *
+	 * @var array(string => string)
+	 */
+	protected $translateContentToToken = array();
+
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		$tokens    = array();
+		$translate = array();
+		foreach ($this->newKeywords as $token => $versions) {
+			if (\defined($token)) {
+				$tokens[] = constant($token);
+			}
+			if (isset($versions['content'])) {
+				$translate[strtolower($versions['content'])] = $token;
+			}
+		}
+
+		/*
          * Deal with tokens not recognized by the PHP version the sniffer is run
          * under and (not correctly) compensated for by PHPCS.
          */
-        if (empty($translate) === false) {
-            $this->translateContentToToken = $translate;
-            $tokens[]                      = \T_STRING;
-        }
-
-        return $tokens;
-    }
-
-
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        $tokens    = $phpcsFile->getTokens();
-        $tokenType = $tokens[$stackPtr]['type'];
-
-        // Allow for dealing with multi-token keywords, like "yield from".
-        $end = $stackPtr;
-
-        // Translate T_STRING token if necessary.
-        if ($tokens[$stackPtr]['type'] === 'T_STRING') {
-            $content = strtolower($tokens[$stackPtr]['content']);
-
-            if (isset($this->translateContentToToken[$content]) === false) {
-                // Not one of the tokens we're looking for.
-                return;
-            }
-
-            $tokenType = $this->translateContentToToken[$content];
-        }
-
-        /*
+		if (empty($translate) === false) {
+			$this->translateContentToToken = $translate;
+			$tokens[]                      = \T_STRING;
+		}
+
+		return $tokens;
+	}
+
+
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		$tokens    = $phpcsFile->getTokens();
+		$tokenType = $tokens[$stackPtr]['type'];
+
+		// Allow for dealing with multi-token keywords, like "yield from".
+		$end = $stackPtr;
+
+		// Translate T_STRING token if necessary.
+		if ($tokens[$stackPtr]['type'] === 'T_STRING') {
+			$content = strtolower($tokens[$stackPtr]['content']);
+
+			if (isset($this->translateContentToToken[$content]) === false) {
+				// Not one of the tokens we're looking for.
+				return;
+			}
+
+			$tokenType = $this->translateContentToToken[$content];
+		}
+
+		/*
          * Special case: distinguish between `yield` and `yield from`.
          *
          * PHPCS currently (at least up to v 3.0.1) does not backfill for the
@@ -227,140 +227,140 @@ 
          * In PHP 7.0+ both are tokenized as their respective token, however,
          * a multi-line "yield from" is tokenized as two tokens.
          */
-        if ($tokenType === 'T_YIELD') {
-            $nextToken = $phpcsFile->findNext(\T_WHITESPACE, ($end + 1), null, true);
-            if ($tokens[$nextToken]['code'] === \T_STRING
-                && $tokens[$nextToken]['content'] === 'from'
-            ) {
-                $tokenType = 'T_YIELD_FROM';
-                $end       = $nextToken;
-            }
-            unset($nextToken);
-        }
-
-        if ($tokenType === 'T_YIELD_FROM' && $tokens[($stackPtr - 1)]['type'] === 'T_YIELD_FROM') {
-            // Multi-line "yield from", no need to report it twice.
-            return;
-        }
-
-        if (isset($this->newKeywords[$tokenType]) === false) {
-            return;
-        }
-
-        $nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true);
-        $prevToken = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
-
-        if ($prevToken !== false
-            && ($tokens[$prevToken]['code'] === \T_DOUBLE_COLON
-            || $tokens[$prevToken]['code'] === \T_OBJECT_OPERATOR)
-        ) {
-            // Class property of the same name as one of the keywords. Ignore.
-            return;
-        }
-
-        // Skip attempts to use keywords as functions or class names - the former
-        // will be reported by ForbiddenNamesAsInvokedFunctionsSniff, whilst the
-        // latter will be (partially) reported by the ForbiddenNames sniff.
-        // Either type will result in false-positives when targetting lower versions
-        // of PHP where the name was not reserved, unless we explicitly check for
-        // them.
-        if (($nextToken === false
-                || $tokens[$nextToken]['type'] !== 'T_OPEN_PARENTHESIS')
-            && ($prevToken === false
-                || $tokens[$prevToken]['type'] !== 'T_CLASS'
-                || $tokens[$prevToken]['type'] !== 'T_INTERFACE')
-        ) {
-            // Skip based on token scope condition.
-            if (isset($this->newKeywords[$tokenType]['condition'])
-                && \call_user_func(array($this, $this->newKeywords[$tokenType]['condition']), $phpcsFile, $stackPtr) === true
-            ) {
-                return;
-            }
-
-            $itemInfo = array(
-                'name'   => $tokenType,
-            );
-            $this->handleFeature($phpcsFile, $stackPtr, $itemInfo);
-        }
-    }
-
-
-    /**
-     * Get the relevant sub-array for a specific item from a multi-dimensional array.
-     *
-     * @param array $itemInfo Base information about the item.
-     *
-     * @return array Version and other information about the item.
-     */
-    public function getItemArray(array $itemInfo)
-    {
-        return $this->newKeywords[$itemInfo['name']];
-    }
-
-
-    /**
-     * Get an array of the non-PHP-version array keys used in a sub-array.
-     *
-     * @return array
-     */
-    protected function getNonVersionArrayKeys()
-    {
-        return array(
-            'description',
-            'condition',
-            'content',
-        );
-    }
-
-
-    /**
-     * Retrieve the relevant detail (version) information for use in an error message.
-     *
-     * @param array $itemArray Version and other information about the item.
-     * @param array $itemInfo  Base information about the item.
-     *
-     * @return array
-     */
-    public function getErrorInfo(array $itemArray, array $itemInfo)
-    {
-        $errorInfo                = parent::getErrorInfo($itemArray, $itemInfo);
-        $errorInfo['description'] = $itemArray['description'];
-
-        return $errorInfo;
-    }
-
-
-    /**
-     * Allow for concrete child classes to filter the error data before it's passed to PHPCS.
-     *
-     * @param array $data      The error data array which was created.
-     * @param array $itemInfo  Base information about the item this error message applies to.
-     * @param array $errorInfo Detail information about an item this error message applies to.
-     *
-     * @return array
-     */
-    protected function filterErrorData(array $data, array $itemInfo, array $errorInfo)
-    {
-        $data[0] = $errorInfo['description'];
-        return $data;
-    }
-
-
-    /**
-     * Callback for the quoted heredoc identifier condition.
-     *
-     * A double quoted identifier will have the opening quote on position 3
-     * in the string: `<<<"ID"`.
-     *
-     * @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 bool
-     */
-    public function isNotQuoted(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-        return ($tokens[$stackPtr]['content'][3] !== '"');
-    }
+		if ($tokenType === 'T_YIELD') {
+			$nextToken = $phpcsFile->findNext(\T_WHITESPACE, ($end + 1), null, true);
+			if ($tokens[$nextToken]['code'] === \T_STRING
+				&& $tokens[$nextToken]['content'] === 'from'
+			) {
+				$tokenType = 'T_YIELD_FROM';
+				$end       = $nextToken;
+			}
+			unset($nextToken);
+		}
+
+		if ($tokenType === 'T_YIELD_FROM' && $tokens[($stackPtr - 1)]['type'] === 'T_YIELD_FROM') {
+			// Multi-line "yield from", no need to report it twice.
+			return;
+		}
+
+		if (isset($this->newKeywords[$tokenType]) === false) {
+			return;
+		}
+
+		$nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true);
+		$prevToken = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
+
+		if ($prevToken !== false
+			&& ($tokens[$prevToken]['code'] === \T_DOUBLE_COLON
+			|| $tokens[$prevToken]['code'] === \T_OBJECT_OPERATOR)
+		) {
+			// Class property of the same name as one of the keywords. Ignore.
+			return;
+		}
+
+		// Skip attempts to use keywords as functions or class names - the former
+		// will be reported by ForbiddenNamesAsInvokedFunctionsSniff, whilst the
+		// latter will be (partially) reported by the ForbiddenNames sniff.
+		// Either type will result in false-positives when targetting lower versions
+		// of PHP where the name was not reserved, unless we explicitly check for
+		// them.
+		if (($nextToken === false
+				|| $tokens[$nextToken]['type'] !== 'T_OPEN_PARENTHESIS')
+			&& ($prevToken === false
+				|| $tokens[$prevToken]['type'] !== 'T_CLASS'
+				|| $tokens[$prevToken]['type'] !== 'T_INTERFACE')
+		) {
+			// Skip based on token scope condition.
+			if (isset($this->newKeywords[$tokenType]['condition'])
+				&& \call_user_func(array($this, $this->newKeywords[$tokenType]['condition']), $phpcsFile, $stackPtr) === true
+			) {
+				return;
+			}
+
+			$itemInfo = array(
+				'name'   => $tokenType,
+			);
+			$this->handleFeature($phpcsFile, $stackPtr, $itemInfo);
+		}
+	}
+
+
+	/**
+	 * Get the relevant sub-array for a specific item from a multi-dimensional array.
+	 *
+	 * @param array $itemInfo Base information about the item.
+	 *
+	 * @return array Version and other information about the item.
+	 */
+	public function getItemArray(array $itemInfo)
+	{
+		return $this->newKeywords[$itemInfo['name']];
+	}
+
+
+	/**
+	 * Get an array of the non-PHP-version array keys used in a sub-array.
+	 *
+	 * @return array
+	 */
+	protected function getNonVersionArrayKeys()
+	{
+		return array(
+			'description',
+			'condition',
+			'content',
+		);
+	}
+
+
+	/**
+	 * Retrieve the relevant detail (version) information for use in an error message.
+	 *
+	 * @param array $itemArray Version and other information about the item.
+	 * @param array $itemInfo  Base information about the item.
+	 *
+	 * @return array
+	 */
+	public function getErrorInfo(array $itemArray, array $itemInfo)
+	{
+		$errorInfo                = parent::getErrorInfo($itemArray, $itemInfo);
+		$errorInfo['description'] = $itemArray['description'];
+
+		return $errorInfo;
+	}
+
+
+	/**
+	 * Allow for concrete child classes to filter the error data before it's passed to PHPCS.
+	 *
+	 * @param array $data      The error data array which was created.
+	 * @param array $itemInfo  Base information about the item this error message applies to.
+	 * @param array $errorInfo Detail information about an item this error message applies to.
+	 *
+	 * @return array
+	 */
+	protected function filterErrorData(array $data, array $itemInfo, array $errorInfo)
+	{
+		$data[0] = $errorInfo['description'];
+		return $data;
+	}
+
+
+	/**
+	 * Callback for the quoted heredoc identifier condition.
+	 *
+	 * A double quoted identifier will have the opening quote on position 3
+	 * in the string: `<<<"ID"`.
+	 *
+	 * @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 bool
+	 */
+	public function isNotQuoted(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+		return ($tokens[$stackPtr]['content'][3] !== '"');
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/Keywords/ForbiddenNamesAsInvokedFunctionsSniff.php

Indentation +140 added lines, -140 removed lines

@@ -27,155 +27,155 @@
 class ForbiddenNamesAsInvokedFunctionsSniff extends Sniff
 {
 
-    /**
-     * List of tokens to register.
-     *
-     * @var array
-     */
-    protected $targetedTokens = array(
-        \T_ABSTRACT   => '5.0',
-        \T_CALLABLE   => '5.4',
-        \T_CATCH      => '5.0',
-        \T_FINAL      => '5.0',
-        \T_FINALLY    => '5.5',
-        \T_GOTO       => '5.3',
-        \T_IMPLEMENTS => '5.0',
-        \T_INTERFACE  => '5.0',
-        \T_INSTANCEOF => '5.0',
-        \T_INSTEADOF  => '5.4',
-        \T_NAMESPACE  => '5.3',
-        \T_PRIVATE    => '5.0',
-        \T_PROTECTED  => '5.0',
-        \T_PUBLIC     => '5.0',
-        \T_TRAIT      => '5.4',
-        \T_TRY        => '5.0',
-
-    );
-
-    /**
-     * T_STRING keywords to recognize as targetted tokens.
-     *
-     * Compatibility for PHP versions where the keyword is not yet recognized
-     * as its own token and for PHPCS versions which change the token to
-     * T_STRING when used in a method call.
-     *
-     * @var array
-     */
-    protected $targetedStringTokens = array(
-        'abstract'   => '5.0',
-        'callable'   => '5.4',
-        'catch'      => '5.0',
-        'final'      => '5.0',
-        'finally'    => '5.5',
-        'goto'       => '5.3',
-        'implements' => '5.0',
-        'interface'  => '5.0',
-        'instanceof' => '5.0',
-        'insteadof'  => '5.4',
-        'namespace'  => '5.3',
-        'private'    => '5.0',
-        'protected'  => '5.0',
-        'public'     => '5.0',
-        'trait'      => '5.4',
-        'try'        => '5.0',
-    );
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        $tokens   = array_keys($this->targetedTokens);
-        $tokens[] = \T_STRING;
-
-        return $tokens;
-    }
-
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        $tokens         = $phpcsFile->getTokens();
-        $tokenCode      = $tokens[$stackPtr]['code'];
-        $tokenContentLc = strtolower($tokens[$stackPtr]['content']);
-        $isString       = false;
-
-        /*
+	/**
+	 * List of tokens to register.
+	 *
+	 * @var array
+	 */
+	protected $targetedTokens = array(
+		\T_ABSTRACT   => '5.0',
+		\T_CALLABLE   => '5.4',
+		\T_CATCH      => '5.0',
+		\T_FINAL      => '5.0',
+		\T_FINALLY    => '5.5',
+		\T_GOTO       => '5.3',
+		\T_IMPLEMENTS => '5.0',
+		\T_INTERFACE  => '5.0',
+		\T_INSTANCEOF => '5.0',
+		\T_INSTEADOF  => '5.4',
+		\T_NAMESPACE  => '5.3',
+		\T_PRIVATE    => '5.0',
+		\T_PROTECTED  => '5.0',
+		\T_PUBLIC     => '5.0',
+		\T_TRAIT      => '5.4',
+		\T_TRY        => '5.0',
+
+	);
+
+	/**
+	 * T_STRING keywords to recognize as targetted tokens.
+	 *
+	 * Compatibility for PHP versions where the keyword is not yet recognized
+	 * as its own token and for PHPCS versions which change the token to
+	 * T_STRING when used in a method call.
+	 *
+	 * @var array
+	 */
+	protected $targetedStringTokens = array(
+		'abstract'   => '5.0',
+		'callable'   => '5.4',
+		'catch'      => '5.0',
+		'final'      => '5.0',
+		'finally'    => '5.5',
+		'goto'       => '5.3',
+		'implements' => '5.0',
+		'interface'  => '5.0',
+		'instanceof' => '5.0',
+		'insteadof'  => '5.4',
+		'namespace'  => '5.3',
+		'private'    => '5.0',
+		'protected'  => '5.0',
+		'public'     => '5.0',
+		'trait'      => '5.4',
+		'try'        => '5.0',
+	);
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		$tokens   = array_keys($this->targetedTokens);
+		$tokens[] = \T_STRING;
+
+		return $tokens;
+	}
+
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		$tokens         = $phpcsFile->getTokens();
+		$tokenCode      = $tokens[$stackPtr]['code'];
+		$tokenContentLc = strtolower($tokens[$stackPtr]['content']);
+		$isString       = false;
+
+		/*
          * For string tokens we only care if the string is a reserved word used
          * as a function. This only happens in older versions of PHP where the
          * token doesn't exist yet for that keyword or in later versions when the
          * token is used in a method invocation.
          */
-        if ($tokenCode === \T_STRING
-            && (isset($this->targetedStringTokens[$tokenContentLc]) === false)
-        ) {
-            return;
-        }
-
-        if ($tokenCode === \T_STRING) {
-            $isString = true;
-        }
-
-        // Make sure this is a function call.
-        $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($next === false || $tokens[$next]['code'] !== \T_OPEN_PARENTHESIS) {
-            // Not a function call.
-            return;
-        }
-
-        // This sniff isn't concerned about function declarations.
-        $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
-        if ($prev !== false && $tokens[$prev]['code'] === \T_FUNCTION) {
-            return;
-        }
-
-        /*
+		if ($tokenCode === \T_STRING
+			&& (isset($this->targetedStringTokens[$tokenContentLc]) === false)
+		) {
+			return;
+		}
+
+		if ($tokenCode === \T_STRING) {
+			$isString = true;
+		}
+
+		// Make sure this is a function call.
+		$next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
+		if ($next === false || $tokens[$next]['code'] !== \T_OPEN_PARENTHESIS) {
+			// Not a function call.
+			return;
+		}
+
+		// This sniff isn't concerned about function declarations.
+		$prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
+		if ($prev !== false && $tokens[$prev]['code'] === \T_FUNCTION) {
+			return;
+		}
+
+		/*
          * Deal with PHP 7 relaxing the rules.
          * "As of PHP 7.0.0 these keywords are allowed as property, constant, and method names
          * of classes, interfaces and traits...", i.e. they can be invoked as a method call.
          *
          * Only needed for those keywords which we sniff out via T_STRING.
          */
-        if (($tokens[$prev]['code'] === \T_OBJECT_OPERATOR || $tokens[$prev]['code'] === \T_DOUBLE_COLON)
-            && $this->supportsBelow('5.6') === false
-        ) {
-            return;
-        }
-
-        // For the word catch, it is valid to have an open parenthesis
-        // after it, but only if it is preceded by a right curly brace.
-        if ($tokenCode === \T_CATCH) {
-            if ($prev !== false && $tokens[$prev]['code'] === \T_CLOSE_CURLY_BRACKET) {
-                // Ok, it's fine.
-                return;
-            }
-        }
-
-        if ($isString === true) {
-            $version = $this->targetedStringTokens[$tokenContentLc];
-        } else {
-            $version = $this->targetedTokens[$tokenCode];
-        }
-
-        if ($this->supportsAbove($version)) {
-            $error     = "'%s' is a reserved keyword introduced in PHP version %s and cannot be invoked as a function (%s)";
-            $errorCode = $this->stringToErrorCode($tokenContentLc) . 'Found';
-            $data      = array(
-                $tokenContentLc,
-                $version,
-                $tokens[$stackPtr]['type'],
-            );
-
-            $phpcsFile->addError($error, $stackPtr, $errorCode, $data);
-        }
-    }
+		if (($tokens[$prev]['code'] === \T_OBJECT_OPERATOR || $tokens[$prev]['code'] === \T_DOUBLE_COLON)
+			&& $this->supportsBelow('5.6') === false
+		) {
+			return;
+		}
+
+		// For the word catch, it is valid to have an open parenthesis
+		// after it, but only if it is preceded by a right curly brace.
+		if ($tokenCode === \T_CATCH) {
+			if ($prev !== false && $tokens[$prev]['code'] === \T_CLOSE_CURLY_BRACKET) {
+				// Ok, it's fine.
+				return;
+			}
+		}
+
+		if ($isString === true) {
+			$version = $this->targetedStringTokens[$tokenContentLc];
+		} else {
+			$version = $this->targetedTokens[$tokenCode];
+		}
+
+		if ($this->supportsAbove($version)) {
+			$error     = "'%s' is a reserved keyword introduced in PHP version %s and cannot be invoked as a function (%s)";
+			$errorCode = $this->stringToErrorCode($tokenContentLc) . 'Found';
+			$data      = array(
+				$tokenContentLc,
+				$version,
+				$tokens[$stackPtr]['type'],
+			);
+
+			$phpcsFile->addError($error, $stackPtr, $errorCode, $data);
+		}
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/Keywords/ForbiddenNamesAsDeclaredSniff.php

Indentation +213 added lines, -213 removed lines

@@ -32,217 +32,217 @@
 class ForbiddenNamesAsDeclaredSniff extends Sniff
 {
 
-    /**
-     * List of tokens which can not be used as class, interface, trait names or as part of a namespace.
-     *
-     * @var array
-     */
-    protected $forbiddenTokens = array(
-        \T_NULL  => '7.0',
-        \T_TRUE  => '7.0',
-        \T_FALSE => '7.0',
-    );
-
-    /**
-     * T_STRING keywords to recognize as forbidden names.
-     *
-     * @var array
-     */
-    protected $forbiddenNames = array(
-        'null'     => '7.0',
-        'true'     => '7.0',
-        'false'    => '7.0',
-        'bool'     => '7.0',
-        'int'      => '7.0',
-        'float'    => '7.0',
-        'string'   => '7.0',
-        'iterable' => '7.1',
-        'void'     => '7.1',
-        'object'   => '7.2',
-    );
-
-    /**
-     * T_STRING keywords to recognize as soft reserved names.
-     *
-     * Using any of these keywords to name a class, interface, trait or namespace
-     * is highly discouraged since they may be used in future versions of PHP.
-     *
-     * @var array
-     */
-    protected $softReservedNames = array(
-        'resource' => '7.0',
-        'object'   => '7.0',
-        'mixed'    => '7.0',
-        'numeric'  => '7.0',
-    );
-
-    /**
-     * Combined list of the two lists above.
-     *
-     * Used for quick check whether or not something is a reserved
-     * word.
-     * Set from the `register()` method.
-     *
-     * @var array
-     */
-    private $allForbiddenNames = array();
-
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        // Do the list merge only once.
-        $this->allForbiddenNames = array_merge($this->forbiddenNames, $this->softReservedNames);
-
-        $targets = array(
-            \T_CLASS,
-            \T_INTERFACE,
-            \T_TRAIT,
-            \T_NAMESPACE,
-            \T_STRING, // Compat for PHPCS < 2.4.0 and PHP < 5.3.
-        );
-
-        return $targets;
-    }
-
-
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        if ($this->supportsAbove('7.0') === false) {
-            return;
-        }
-
-        $tokens         = $phpcsFile->getTokens();
-        $tokenCode      = $tokens[$stackPtr]['code'];
-        $tokenType      = $tokens[$stackPtr]['type'];
-        $tokenContentLc = strtolower($tokens[$stackPtr]['content']);
-
-        // For string tokens we only care about 'trait' as that is the only one
-        // which may not be correctly recognized as it's own token.
-        // This only happens in older versions of PHP where the token doesn't exist yet as a keyword.
-        if ($tokenCode === \T_STRING && $tokenContentLc !== 'trait') {
-            return;
-        }
-
-        if (\in_array($tokenType, array('T_CLASS', 'T_INTERFACE', 'T_TRAIT'), true)) {
-            // Check for the declared name being a name which is not tokenized as T_STRING.
-            $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-            if ($nextNonEmpty !== false && isset($this->forbiddenTokens[$tokens[$nextNonEmpty]['code']]) === true) {
-                $name = $tokens[$nextNonEmpty]['content'];
-            } else {
-                // Get the declared name if it's a T_STRING.
-                $name = $phpcsFile->getDeclarationName($stackPtr);
-            }
-            unset($nextNonEmpty);
-
-            if (isset($name) === false || \is_string($name) === false || $name === '') {
-                return;
-            }
-
-            $nameLc = strtolower($name);
-            if (isset($this->allForbiddenNames[$nameLc]) === false) {
-                return;
-            }
-
-        } elseif ($tokenCode === \T_NAMESPACE) {
-            $namespaceName = $this->getDeclaredNamespaceName($phpcsFile, $stackPtr);
-
-            if ($namespaceName === false || $namespaceName === '') {
-                return;
-            }
-
-            $namespaceParts = explode('\\', $namespaceName);
-            foreach ($namespaceParts as $namespacePart) {
-                $partLc = strtolower($namespacePart);
-                if (isset($this->allForbiddenNames[$partLc]) === true) {
-                    $name   = $namespacePart;
-                    $nameLc = $partLc;
-                    break;
-                }
-            }
-        } elseif ($tokenCode === \T_STRING) {
-            // Traits which are not yet tokenized as T_TRAIT.
-            $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-            if ($nextNonEmpty === false) {
-                return;
-            }
-
-            $nextNonEmptyCode = $tokens[$nextNonEmpty]['code'];
-
-            if ($nextNonEmptyCode !== \T_STRING && isset($this->forbiddenTokens[$nextNonEmptyCode]) === true) {
-                $name   = $tokens[$nextNonEmpty]['content'];
-                $nameLc = strtolower($tokens[$nextNonEmpty]['content']);
-            } elseif ($nextNonEmptyCode === \T_STRING) {
-                $endOfStatement = $phpcsFile->findNext(array(\T_SEMICOLON, \T_OPEN_CURLY_BRACKET), ($stackPtr + 1));
-                if ($endOfStatement === false) {
-                    return;
-                }
-
-                do {
-                    $nextNonEmptyLc = strtolower($tokens[$nextNonEmpty]['content']);
-
-                    if (isset($this->allForbiddenNames[$nextNonEmptyLc]) === true) {
-                        $name   = $tokens[$nextNonEmpty]['content'];
-                        $nameLc = $nextNonEmptyLc;
-                        break;
-                    }
-
-                    $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), $endOfStatement, true);
-                } while ($nextNonEmpty !== false);
-            }
-            unset($nextNonEmptyCode, $nextNonEmptyLc, $endOfStatement);
-        }
-
-        if (isset($name, $nameLc) === false) {
-            return;
-        }
-
-        // Still here, so this is one of the reserved words.
-        // Build up the error message.
-        $error     = "'%s' is a";
-        $isError   = null;
-        $errorCode = $this->stringToErrorCode($nameLc) . 'Found';
-        $data      = array(
-            $nameLc,
-        );
-
-        if (isset($this->softReservedNames[$nameLc]) === true
-            && $this->supportsAbove($this->softReservedNames[$nameLc]) === true
-        ) {
-            $error  .= ' soft reserved keyword as of PHP version %s';
-            $isError = false;
-            $data[]  = $this->softReservedNames[$nameLc];
-        }
-
-        if (isset($this->forbiddenNames[$nameLc]) === true
-            && $this->supportsAbove($this->forbiddenNames[$nameLc]) === true
-        ) {
-            if (isset($isError) === true) {
-                $error .= ' and a';
-            }
-            $error  .= ' reserved keyword as of PHP version %s';
-            $isError = true;
-            $data[]  = $this->forbiddenNames[$nameLc];
-        }
-
-        if (isset($isError) === true) {
-            $error .= ' and should not be used to name a class, interface or trait or as part of a namespace (%s)';
-            $data[] = $tokens[$stackPtr]['type'];
-
-            $this->addMessage($phpcsFile, $error, $stackPtr, $isError, $errorCode, $data);
-        }
-    }
+	/**
+	 * List of tokens which can not be used as class, interface, trait names or as part of a namespace.
+	 *
+	 * @var array
+	 */
+	protected $forbiddenTokens = array(
+		\T_NULL  => '7.0',
+		\T_TRUE  => '7.0',
+		\T_FALSE => '7.0',
+	);
+
+	/**
+	 * T_STRING keywords to recognize as forbidden names.
+	 *
+	 * @var array
+	 */
+	protected $forbiddenNames = array(
+		'null'     => '7.0',
+		'true'     => '7.0',
+		'false'    => '7.0',
+		'bool'     => '7.0',
+		'int'      => '7.0',
+		'float'    => '7.0',
+		'string'   => '7.0',
+		'iterable' => '7.1',
+		'void'     => '7.1',
+		'object'   => '7.2',
+	);
+
+	/**
+	 * T_STRING keywords to recognize as soft reserved names.
+	 *
+	 * Using any of these keywords to name a class, interface, trait or namespace
+	 * is highly discouraged since they may be used in future versions of PHP.
+	 *
+	 * @var array
+	 */
+	protected $softReservedNames = array(
+		'resource' => '7.0',
+		'object'   => '7.0',
+		'mixed'    => '7.0',
+		'numeric'  => '7.0',
+	);
+
+	/**
+	 * Combined list of the two lists above.
+	 *
+	 * Used for quick check whether or not something is a reserved
+	 * word.
+	 * Set from the `register()` method.
+	 *
+	 * @var array
+	 */
+	private $allForbiddenNames = array();
+
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		// Do the list merge only once.
+		$this->allForbiddenNames = array_merge($this->forbiddenNames, $this->softReservedNames);
+
+		$targets = array(
+			\T_CLASS,
+			\T_INTERFACE,
+			\T_TRAIT,
+			\T_NAMESPACE,
+			\T_STRING, // Compat for PHPCS < 2.4.0 and PHP < 5.3.
+		);
+
+		return $targets;
+	}
+
+
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		if ($this->supportsAbove('7.0') === false) {
+			return;
+		}
+
+		$tokens         = $phpcsFile->getTokens();
+		$tokenCode      = $tokens[$stackPtr]['code'];
+		$tokenType      = $tokens[$stackPtr]['type'];
+		$tokenContentLc = strtolower($tokens[$stackPtr]['content']);
+
+		// For string tokens we only care about 'trait' as that is the only one
+		// which may not be correctly recognized as it's own token.
+		// This only happens in older versions of PHP where the token doesn't exist yet as a keyword.
+		if ($tokenCode === \T_STRING && $tokenContentLc !== 'trait') {
+			return;
+		}
+
+		if (\in_array($tokenType, array('T_CLASS', 'T_INTERFACE', 'T_TRAIT'), true)) {
+			// Check for the declared name being a name which is not tokenized as T_STRING.
+			$nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
+			if ($nextNonEmpty !== false && isset($this->forbiddenTokens[$tokens[$nextNonEmpty]['code']]) === true) {
+				$name = $tokens[$nextNonEmpty]['content'];
+			} else {
+				// Get the declared name if it's a T_STRING.
+				$name = $phpcsFile->getDeclarationName($stackPtr);
+			}
+			unset($nextNonEmpty);
+
+			if (isset($name) === false || \is_string($name) === false || $name === '') {
+				return;
+			}
+
+			$nameLc = strtolower($name);
+			if (isset($this->allForbiddenNames[$nameLc]) === false) {
+				return;
+			}
+
+		} elseif ($tokenCode === \T_NAMESPACE) {
+			$namespaceName = $this->getDeclaredNamespaceName($phpcsFile, $stackPtr);
+
+			if ($namespaceName === false || $namespaceName === '') {
+				return;
+			}
+
+			$namespaceParts = explode('\\', $namespaceName);
+			foreach ($namespaceParts as $namespacePart) {
+				$partLc = strtolower($namespacePart);
+				if (isset($this->allForbiddenNames[$partLc]) === true) {
+					$name   = $namespacePart;
+					$nameLc = $partLc;
+					break;
+				}
+			}
+		} elseif ($tokenCode === \T_STRING) {
+			// Traits which are not yet tokenized as T_TRAIT.
+			$nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
+			if ($nextNonEmpty === false) {
+				return;
+			}
+
+			$nextNonEmptyCode = $tokens[$nextNonEmpty]['code'];
+
+			if ($nextNonEmptyCode !== \T_STRING && isset($this->forbiddenTokens[$nextNonEmptyCode]) === true) {
+				$name   = $tokens[$nextNonEmpty]['content'];
+				$nameLc = strtolower($tokens[$nextNonEmpty]['content']);
+			} elseif ($nextNonEmptyCode === \T_STRING) {
+				$endOfStatement = $phpcsFile->findNext(array(\T_SEMICOLON, \T_OPEN_CURLY_BRACKET), ($stackPtr + 1));
+				if ($endOfStatement === false) {
+					return;
+				}
+
+				do {
+					$nextNonEmptyLc = strtolower($tokens[$nextNonEmpty]['content']);
+
+					if (isset($this->allForbiddenNames[$nextNonEmptyLc]) === true) {
+						$name   = $tokens[$nextNonEmpty]['content'];
+						$nameLc = $nextNonEmptyLc;
+						break;
+					}
+
+					$nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), $endOfStatement, true);
+				} while ($nextNonEmpty !== false);
+			}
+			unset($nextNonEmptyCode, $nextNonEmptyLc, $endOfStatement);
+		}
+
+		if (isset($name, $nameLc) === false) {
+			return;
+		}
+
+		// Still here, so this is one of the reserved words.
+		// Build up the error message.
+		$error     = "'%s' is a";
+		$isError   = null;
+		$errorCode = $this->stringToErrorCode($nameLc) . 'Found';
+		$data      = array(
+			$nameLc,
+		);
+
+		if (isset($this->softReservedNames[$nameLc]) === true
+			&& $this->supportsAbove($this->softReservedNames[$nameLc]) === true
+		) {
+			$error  .= ' soft reserved keyword as of PHP version %s';
+			$isError = false;
+			$data[]  = $this->softReservedNames[$nameLc];
+		}
+
+		if (isset($this->forbiddenNames[$nameLc]) === true
+			&& $this->supportsAbove($this->forbiddenNames[$nameLc]) === true
+		) {
+			if (isset($isError) === true) {
+				$error .= ' and a';
+			}
+			$error  .= ' reserved keyword as of PHP version %s';
+			$isError = true;
+			$data[]  = $this->forbiddenNames[$nameLc];
+		}
+
+		if (isset($isError) === true) {
+			$error .= ' and should not be used to name a class, interface or trait or as part of a namespace (%s)';
+			$data[] = $tokens[$stackPtr]['type'];
+
+			$this->addMessage($phpcsFile, $error, $stackPtr, $isError, $errorCode, $data);
+		}
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/Keywords/CaseSensitiveKeywordsSniff.php

Indentation +38 added lines, -38 removed lines

@@ -29,45 +29,45 @@
 class CaseSensitiveKeywordsSniff extends Sniff
 {
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return array(
-            \T_SELF,
-            \T_STATIC,
-            \T_PARENT,
-        );
-    }
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return array(
+			\T_SELF,
+			\T_STATIC,
+			\T_PARENT,
+		);
+	}
 
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        if ($this->supportsBelow('5.4') === false) {
-            return;
-        }
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		if ($this->supportsBelow('5.4') === false) {
+			return;
+		}
 
-        $tokens         = $phpcsFile->getTokens();
-        $tokenContentLC = strtolower($tokens[$stackPtr]['content']);
+		$tokens         = $phpcsFile->getTokens();
+		$tokenContentLC = strtolower($tokens[$stackPtr]['content']);
 
-        if ($tokenContentLC !== $tokens[$stackPtr]['content']) {
-            $phpcsFile->addError(
-                'The keyword \'%s\' was treated in a case-sensitive fashion in certain cases in PHP 5.4 or earlier. Use the lowercase version for consistent support.',
-                $stackPtr,
-                'NonLowercaseFound',
-                array($tokenContentLC)
-            );
-        }
-    }
+		if ($tokenContentLC !== $tokens[$stackPtr]['content']) {
+			$phpcsFile->addError(
+				'The keyword \'%s\' was treated in a case-sensitive fashion in certain cases in PHP 5.4 or earlier. Use the lowercase version for consistent support.',
+				$stackPtr,
+				'NonLowercaseFound',
+				array($tokenContentLC)
+			);
+		}
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/Keywords/ForbiddenNamesSniff.php

Indentation +335 added lines, -335 removed lines

@@ -27,365 +27,365 @@
 class ForbiddenNamesSniff extends Sniff
 {
 
-    /**
-     * A list of keywords that can not be used as function, class and namespace name or constant name.
-     * Mentions since which version it's not allowed.
-     *
-     * @var array(string => string)
-     */
-    protected $invalidNames = array(
-        'abstract'      => '5.0',
-        'and'           => 'all',
-        'array'         => 'all',
-        'as'            => 'all',
-        'break'         => 'all',
-        'callable'      => '5.4',
-        'case'          => 'all',
-        'catch'         => '5.0',
-        'class'         => 'all',
-        'clone'         => '5.0',
-        'const'         => 'all',
-        'continue'      => 'all',
-        'declare'       => 'all',
-        'default'       => 'all',
-        'do'            => 'all',
-        'else'          => 'all',
-        'elseif'        => 'all',
-        'enddeclare'    => 'all',
-        'endfor'        => 'all',
-        'endforeach'    => 'all',
-        'endif'         => 'all',
-        'endswitch'     => 'all',
-        'endwhile'      => 'all',
-        'extends'       => 'all',
-        'final'         => '5.0',
-        'finally'       => '5.5',
-        'for'           => 'all',
-        'foreach'       => 'all',
-        'function'      => 'all',
-        'global'        => 'all',
-        'goto'          => '5.3',
-        'if'            => 'all',
-        'implements'    => '5.0',
-        'interface'     => '5.0',
-        'instanceof'    => '5.0',
-        'insteadof'     => '5.4',
-        'namespace'     => '5.3',
-        'new'           => 'all',
-        'or'            => 'all',
-        'private'       => '5.0',
-        'protected'     => '5.0',
-        'public'        => '5.0',
-        'static'        => 'all',
-        'switch'        => 'all',
-        'throw'         => '5.0',
-        'trait'         => '5.4',
-        'try'           => '5.0',
-        'use'           => 'all',
-        'var'           => 'all',
-        'while'         => 'all',
-        'xor'           => 'all',
-        '__class__'     => 'all',
-        '__dir__'       => '5.3',
-        '__file__'      => 'all',
-        '__function__'  => 'all',
-        '__method__'    => 'all',
-        '__namespace__' => '5.3',
-    );
-
-    /**
-     * A list of keywords that can follow use statements.
-     *
-     * @var array(string => string)
-     */
-    protected $validUseNames = array(
-        'const'    => true,
-        'function' => true,
-    );
-
-    /**
-     * Scope modifiers and other keywords allowed in trait use statements.
-     *
-     * @var array
-     */
-    private $allowedModifiers = array();
-
-    /**
-     * Targeted tokens.
-     *
-     * @var array
-     */
-    protected $targetedTokens = array(
-        \T_CLASS,
-        \T_FUNCTION,
-        \T_NAMESPACE,
-        \T_STRING,
-        \T_CONST,
-        \T_USE,
-        \T_AS,
-        \T_EXTENDS,
-        \T_INTERFACE,
-        \T_TRAIT,
-    );
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        $this->allowedModifiers           = Tokens::$scopeModifiers;
-        $this->allowedModifiers[\T_FINAL] = \T_FINAL;
-
-        $tokens = $this->targetedTokens;
-
-        if (\defined('T_ANON_CLASS')) {
-            $tokens[] = \T_ANON_CLASS;
-        }
-
-        return $tokens;
-    }
-
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        /*
+	/**
+	 * A list of keywords that can not be used as function, class and namespace name or constant name.
+	 * Mentions since which version it's not allowed.
+	 *
+	 * @var array(string => string)
+	 */
+	protected $invalidNames = array(
+		'abstract'      => '5.0',
+		'and'           => 'all',
+		'array'         => 'all',
+		'as'            => 'all',
+		'break'         => 'all',
+		'callable'      => '5.4',
+		'case'          => 'all',
+		'catch'         => '5.0',
+		'class'         => 'all',
+		'clone'         => '5.0',
+		'const'         => 'all',
+		'continue'      => 'all',
+		'declare'       => 'all',
+		'default'       => 'all',
+		'do'            => 'all',
+		'else'          => 'all',
+		'elseif'        => 'all',
+		'enddeclare'    => 'all',
+		'endfor'        => 'all',
+		'endforeach'    => 'all',
+		'endif'         => 'all',
+		'endswitch'     => 'all',
+		'endwhile'      => 'all',
+		'extends'       => 'all',
+		'final'         => '5.0',
+		'finally'       => '5.5',
+		'for'           => 'all',
+		'foreach'       => 'all',
+		'function'      => 'all',
+		'global'        => 'all',
+		'goto'          => '5.3',
+		'if'            => 'all',
+		'implements'    => '5.0',
+		'interface'     => '5.0',
+		'instanceof'    => '5.0',
+		'insteadof'     => '5.4',
+		'namespace'     => '5.3',
+		'new'           => 'all',
+		'or'            => 'all',
+		'private'       => '5.0',
+		'protected'     => '5.0',
+		'public'        => '5.0',
+		'static'        => 'all',
+		'switch'        => 'all',
+		'throw'         => '5.0',
+		'trait'         => '5.4',
+		'try'           => '5.0',
+		'use'           => 'all',
+		'var'           => 'all',
+		'while'         => 'all',
+		'xor'           => 'all',
+		'__class__'     => 'all',
+		'__dir__'       => '5.3',
+		'__file__'      => 'all',
+		'__function__'  => 'all',
+		'__method__'    => 'all',
+		'__namespace__' => '5.3',
+	);
+
+	/**
+	 * A list of keywords that can follow use statements.
+	 *
+	 * @var array(string => string)
+	 */
+	protected $validUseNames = array(
+		'const'    => true,
+		'function' => true,
+	);
+
+	/**
+	 * Scope modifiers and other keywords allowed in trait use statements.
+	 *
+	 * @var array
+	 */
+	private $allowedModifiers = array();
+
+	/**
+	 * Targeted tokens.
+	 *
+	 * @var array
+	 */
+	protected $targetedTokens = array(
+		\T_CLASS,
+		\T_FUNCTION,
+		\T_NAMESPACE,
+		\T_STRING,
+		\T_CONST,
+		\T_USE,
+		\T_AS,
+		\T_EXTENDS,
+		\T_INTERFACE,
+		\T_TRAIT,
+	);
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		$this->allowedModifiers           = Tokens::$scopeModifiers;
+		$this->allowedModifiers[\T_FINAL] = \T_FINAL;
+
+		$tokens = $this->targetedTokens;
+
+		if (\defined('T_ANON_CLASS')) {
+			$tokens[] = \T_ANON_CLASS;
+		}
+
+		return $tokens;
+	}
+
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		/*
          * We distinguish between the class, function and namespace names vs the define statements.
          */
-        if ($tokens[$stackPtr]['type'] === 'T_STRING') {
-            $this->processString($phpcsFile, $stackPtr, $tokens);
-        } else {
-            $this->processNonString($phpcsFile, $stackPtr, $tokens);
-        }
-    }
-
-    /**
-     * 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.
-     * @param array                 $tokens    The stack of tokens that make up
-     *                                         the file.
-     *
-     * @return void
-     */
-    public function processNonString(File $phpcsFile, $stackPtr, $tokens)
-    {
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($nextNonEmpty === false) {
-            return;
-        }
-
-        /*
+		if ($tokens[$stackPtr]['type'] === 'T_STRING') {
+			$this->processString($phpcsFile, $stackPtr, $tokens);
+		} else {
+			$this->processNonString($phpcsFile, $stackPtr, $tokens);
+		}
+	}
+
+	/**
+	 * 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.
+	 * @param array                 $tokens    The stack of tokens that make up
+	 *                                         the file.
+	 *
+	 * @return void
+	 */
+	public function processNonString(File $phpcsFile, $stackPtr, $tokens)
+	{
+		$nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
+		if ($nextNonEmpty === false) {
+			return;
+		}
+
+		/*
          * Deal with anonymous classes - `class` before a reserved keyword is sometimes
          * misidentified as `T_ANON_CLASS`.
          * In PHPCS < 2.3.4 these were tokenized as T_CLASS no matter what.
          */
-        if ($tokens[$stackPtr]['type'] === 'T_ANON_CLASS' || $tokens[$stackPtr]['type'] === 'T_CLASS') {
-            $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
-            if ($prevNonEmpty !== false && $tokens[$prevNonEmpty]['type'] === 'T_NEW') {
-                return;
-            }
-        }
-
-        /*
+		if ($tokens[$stackPtr]['type'] === 'T_ANON_CLASS' || $tokens[$stackPtr]['type'] === 'T_CLASS') {
+			$prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
+			if ($prevNonEmpty !== false && $tokens[$prevNonEmpty]['type'] === 'T_NEW') {
+				return;
+			}
+		}
+
+		/*
          * PHP 5.6 allows for use const and use function, but only if followed by the function/constant name.
          * - `use function HelloWorld` => move to the next token (HelloWorld) to verify.
          * - `use const HelloWorld` => move to the next token (HelloWorld) to verify.
          */
-        elseif ($tokens[$stackPtr]['type'] === 'T_USE'
-            && isset($this->validUseNames[strtolower($tokens[$nextNonEmpty]['content'])]) === true
-        ) {
-            $maybeUseNext = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), null, true, null, true);
-            if ($maybeUseNext !== false && $this->isEndOfUseStatement($tokens[$maybeUseNext]) === false) {
-                $nextNonEmpty = $maybeUseNext;
-            }
-        }
-
-        /*
+		elseif ($tokens[$stackPtr]['type'] === 'T_USE'
+			&& isset($this->validUseNames[strtolower($tokens[$nextNonEmpty]['content'])]) === true
+		) {
+			$maybeUseNext = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), null, true, null, true);
+			if ($maybeUseNext !== false && $this->isEndOfUseStatement($tokens[$maybeUseNext]) === false) {
+				$nextNonEmpty = $maybeUseNext;
+			}
+		}
+
+		/*
          * Deal with visibility modifiers.
          * - `use HelloWorld { sayHello as protected; }` => valid, bow out.
          * - `use HelloWorld { sayHello as private myPrivateHello; }` => move to the next token to verify.
          */
-        elseif ($tokens[$stackPtr]['type'] === 'T_AS'
-            && isset($this->allowedModifiers[$tokens[$nextNonEmpty]['code']]) === true
-            && $phpcsFile->hasCondition($stackPtr, \T_USE) === true
-        ) {
-            $maybeUseNext = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), null, true, null, true);
-            if ($maybeUseNext === false || $this->isEndOfUseStatement($tokens[$maybeUseNext]) === true) {
-                return;
-            }
-
-            $nextNonEmpty = $maybeUseNext;
-        }
-
-        /*
+		elseif ($tokens[$stackPtr]['type'] === 'T_AS'
+			&& isset($this->allowedModifiers[$tokens[$nextNonEmpty]['code']]) === true
+			&& $phpcsFile->hasCondition($stackPtr, \T_USE) === true
+		) {
+			$maybeUseNext = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), null, true, null, true);
+			if ($maybeUseNext === false || $this->isEndOfUseStatement($tokens[$maybeUseNext]) === true) {
+				return;
+			}
+
+			$nextNonEmpty = $maybeUseNext;
+		}
+
+		/*
          * Deal with functions declared to return by reference.
          */
-        elseif ($tokens[$stackPtr]['type'] === 'T_FUNCTION'
-            && $tokens[$nextNonEmpty]['type'] === 'T_BITWISE_AND'
-        ) {
-            $maybeUseNext = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), null, true, null, true);
-            if ($maybeUseNext === false) {
-                // Live coding.
-                return;
-            }
-
-            $nextNonEmpty = $maybeUseNext;
-        }
-
-        /*
+		elseif ($tokens[$stackPtr]['type'] === 'T_FUNCTION'
+			&& $tokens[$nextNonEmpty]['type'] === 'T_BITWISE_AND'
+		) {
+			$maybeUseNext = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), null, true, null, true);
+			if ($maybeUseNext === false) {
+				// Live coding.
+				return;
+			}
+
+			$nextNonEmpty = $maybeUseNext;
+		}
+
+		/*
          * Deal with nested namespaces.
          */
-        elseif ($tokens[$stackPtr]['type'] === 'T_NAMESPACE') {
-            if ($tokens[$stackPtr + 1]['code'] === \T_NS_SEPARATOR) {
-                // Not a namespace declaration, but use of, i.e. namespace\someFunction();
-                return;
-            }
-
-            $endToken      = $phpcsFile->findNext(array(\T_SEMICOLON, \T_OPEN_CURLY_BRACKET), ($stackPtr + 1), null, false, null, true);
-            $namespaceName = trim($phpcsFile->getTokensAsString(($stackPtr + 1), ($endToken - $stackPtr - 1)));
-            if (empty($namespaceName) === true) {
-                return;
-            }
-
-            $namespaceParts = explode('\\', $namespaceName);
-            foreach ($namespaceParts as $namespacePart) {
-                $partLc = strtolower($namespacePart);
-                if (isset($this->invalidNames[$partLc]) === false) {
-                    continue;
-                }
-
-                // Find the token position of the part which matched.
-                for ($i = ($stackPtr + 1); $i < $endToken; $i++) {
-                    if ($tokens[$i]['content'] === $namespacePart) {
-                        $nextNonEmpty = $i;
-                        break;
-                    }
-                }
-            }
-            unset($i, $namespacePart, $partLc);
-        }
-
-        $nextContentLc = strtolower($tokens[$nextNonEmpty]['content']);
-        if (isset($this->invalidNames[$nextContentLc]) === false) {
-            return;
-        }
-
-        /*
+		elseif ($tokens[$stackPtr]['type'] === 'T_NAMESPACE') {
+			if ($tokens[$stackPtr + 1]['code'] === \T_NS_SEPARATOR) {
+				// Not a namespace declaration, but use of, i.e. namespace\someFunction();
+				return;
+			}
+
+			$endToken      = $phpcsFile->findNext(array(\T_SEMICOLON, \T_OPEN_CURLY_BRACKET), ($stackPtr + 1), null, false, null, true);
+			$namespaceName = trim($phpcsFile->getTokensAsString(($stackPtr + 1), ($endToken - $stackPtr - 1)));
+			if (empty($namespaceName) === true) {
+				return;
+			}
+
+			$namespaceParts = explode('\\', $namespaceName);
+			foreach ($namespaceParts as $namespacePart) {
+				$partLc = strtolower($namespacePart);
+				if (isset($this->invalidNames[$partLc]) === false) {
+					continue;
+				}
+
+				// Find the token position of the part which matched.
+				for ($i = ($stackPtr + 1); $i < $endToken; $i++) {
+					if ($tokens[$i]['content'] === $namespacePart) {
+						$nextNonEmpty = $i;
+						break;
+					}
+				}
+			}
+			unset($i, $namespacePart, $partLc);
+		}
+
+		$nextContentLc = strtolower($tokens[$nextNonEmpty]['content']);
+		if (isset($this->invalidNames[$nextContentLc]) === false) {
+			return;
+		}
+
+		/*
          * Deal with PHP 7 relaxing the rules.
          * "As of PHP 7.0.0 these keywords are allowed as property, constant, and method names
          * of classes, interfaces and traits, except that class may not be used as constant name."
          */
-        if ((($tokens[$stackPtr]['type'] === 'T_FUNCTION'
-                && $this->inClassScope($phpcsFile, $stackPtr, false) === true)
-            || ($tokens[$stackPtr]['type'] === 'T_CONST'
-                && $this->isClassConstant($phpcsFile, $stackPtr) === true
-                && $nextContentLc !== 'class'))
-            && $this->supportsBelow('5.6') === false
-        ) {
-            return;
-        }
-
-        if ($this->supportsAbove($this->invalidNames[$nextContentLc])) {
-            $data = array(
-                $tokens[$nextNonEmpty]['content'],
-                $this->invalidNames[$nextContentLc],
-            );
-            $this->addError($phpcsFile, $stackPtr, $tokens[$nextNonEmpty]['content'], $data);
-        }
-    }
-
-    /**
-     * 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.
-     * @param array                 $tokens    The stack of tokens that make up
-     *                                         the file.
-     *
-     * @return void
-     */
-    public function processString(File $phpcsFile, $stackPtr, $tokens)
-    {
-        $tokenContentLc = strtolower($tokens[$stackPtr]['content']);
-
-        /*
+		if ((($tokens[$stackPtr]['type'] === 'T_FUNCTION'
+				&& $this->inClassScope($phpcsFile, $stackPtr, false) === true)
+			|| ($tokens[$stackPtr]['type'] === 'T_CONST'
+				&& $this->isClassConstant($phpcsFile, $stackPtr) === true
+				&& $nextContentLc !== 'class'))
+			&& $this->supportsBelow('5.6') === false
+		) {
+			return;
+		}
+
+		if ($this->supportsAbove($this->invalidNames[$nextContentLc])) {
+			$data = array(
+				$tokens[$nextNonEmpty]['content'],
+				$this->invalidNames[$nextContentLc],
+			);
+			$this->addError($phpcsFile, $stackPtr, $tokens[$nextNonEmpty]['content'], $data);
+		}
+	}
+
+	/**
+	 * 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.
+	 * @param array                 $tokens    The stack of tokens that make up
+	 *                                         the file.
+	 *
+	 * @return void
+	 */
+	public function processString(File $phpcsFile, $stackPtr, $tokens)
+	{
+		$tokenContentLc = strtolower($tokens[$stackPtr]['content']);
+
+		/*
          * Special case for PHP versions where the target is not yet identified as
          * its own token, but presents as T_STRING.
          * - trait keyword in PHP < 5.4
          */
-        if (version_compare(\PHP_VERSION_ID, '50400', '<') && $tokenContentLc === 'trait') {
-            $this->processNonString($phpcsFile, $stackPtr, $tokens);
-            return;
-        }
-
-        // Look for any define/defined tokens (both T_STRING ones, blame Tokenizer).
-        if ($tokenContentLc !== 'define' && $tokenContentLc !== 'defined') {
-            return;
-        }
-
-        // Retrieve the define(d) constant name.
-        $firstParam = $this->getFunctionCallParameter($phpcsFile, $stackPtr, 1);
-        if ($firstParam === false) {
-            return;
-        }
-
-        $defineName   = $this->stripQuotes($firstParam['raw']);
-        $defineNameLc = strtolower($defineName);
-
-        if (isset($this->invalidNames[$defineNameLc]) && $this->supportsAbove($this->invalidNames[$defineNameLc])) {
-            $data = array(
-                $defineName,
-                $this->invalidNames[$defineNameLc],
-            );
-            $this->addError($phpcsFile, $stackPtr, $defineNameLc, $data);
-        }
-    }
-
-
-    /**
-     * Add the error message.
-     *
-     * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
-     * @param int                   $stackPtr  The position of the current token in the
-     *                                         stack passed in $tokens.
-     * @param string                $content   The token content found.
-     * @param array                 $data      The data to pass into the error message.
-     *
-     * @return void
-     */
-    protected function addError(File $phpcsFile, $stackPtr, $content, $data)
-    {
-        $error     = "Function name, class name, namespace name or constant name can not be reserved keyword '%s' (since version %s)";
-        $errorCode = $this->stringToErrorCode($content) . 'Found';
-        $phpcsFile->addError($error, $stackPtr, $errorCode, $data);
-    }
-
-
-    /**
-     * Check if the current token code is for a token which can be considered
-     * the end of a (partial) use statement.
-     *
-     * @param int $token The current token information.
-     *
-     * @return bool
-     */
-    protected function isEndOfUseStatement($token)
-    {
-        return \in_array($token['code'], array(\T_CLOSE_CURLY_BRACKET, \T_SEMICOLON, \T_COMMA), true);
-    }
+		if (version_compare(\PHP_VERSION_ID, '50400', '<') && $tokenContentLc === 'trait') {
+			$this->processNonString($phpcsFile, $stackPtr, $tokens);
+			return;
+		}
+
+		// Look for any define/defined tokens (both T_STRING ones, blame Tokenizer).
+		if ($tokenContentLc !== 'define' && $tokenContentLc !== 'defined') {
+			return;
+		}
+
+		// Retrieve the define(d) constant name.
+		$firstParam = $this->getFunctionCallParameter($phpcsFile, $stackPtr, 1);
+		if ($firstParam === false) {
+			return;
+		}
+
+		$defineName   = $this->stripQuotes($firstParam['raw']);
+		$defineNameLc = strtolower($defineName);
+
+		if (isset($this->invalidNames[$defineNameLc]) && $this->supportsAbove($this->invalidNames[$defineNameLc])) {
+			$data = array(
+				$defineName,
+				$this->invalidNames[$defineNameLc],
+			);
+			$this->addError($phpcsFile, $stackPtr, $defineNameLc, $data);
+		}
+	}
+
+
+	/**
+	 * Add the error message.
+	 *
+	 * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
+	 * @param int                   $stackPtr  The position of the current token in the
+	 *                                         stack passed in $tokens.
+	 * @param string                $content   The token content found.
+	 * @param array                 $data      The data to pass into the error message.
+	 *
+	 * @return void
+	 */
+	protected function addError(File $phpcsFile, $stackPtr, $content, $data)
+	{
+		$error     = "Function name, class name, namespace name or constant name can not be reserved keyword '%s' (since version %s)";
+		$errorCode = $this->stringToErrorCode($content) . 'Found';
+		$phpcsFile->addError($error, $stackPtr, $errorCode, $data);
+	}
+
+
+	/**
+	 * Check if the current token code is for a token which can be considered
+	 * the end of a (partial) use statement.
+	 *
+	 * @param int $token The current token information.
+	 *
+	 * @return bool
+	 */
+	protected function isEndOfUseStatement($token)
+	{
+		return \in_array($token['code'], array(\T_CLOSE_CURLY_BRACKET, \T_SEMICOLON, \T_COMMA), true);
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/ControlStructures/DiscouragedSwitchContinueSniff.php

Indentation +191 added lines, -191 removed lines

@@ -29,195 +29,195 @@
 class DiscouragedSwitchContinueSniff extends Sniff
 {
 
-    /**
-     * Token codes of control structures which can be targeted using continue.
-     *
-     * @var array
-     */
-    protected $loopStructures = array(
-        \T_FOR     => \T_FOR,
-        \T_FOREACH => \T_FOREACH,
-        \T_WHILE   => \T_WHILE,
-        \T_DO      => \T_DO,
-        \T_SWITCH  => \T_SWITCH,
-    );
-
-    /**
-     * Tokens which start a new case within a switch.
-     *
-     * @var array
-     */
-    protected $caseTokens = array(
-        \T_CASE    => \T_CASE,
-        \T_DEFAULT => \T_DEFAULT,
-    );
-
-    /**
-     * Token codes which are accepted to determine the level for the continue.
-     *
-     * This array is enriched with the arithmetic operators in the register() method.
-     *
-     * @var array
-     */
-    protected $acceptedLevelTokens = array(
-        \T_LNUMBER           => \T_LNUMBER,
-        \T_OPEN_PARENTHESIS  => \T_OPEN_PARENTHESIS,
-        \T_CLOSE_PARENTHESIS => \T_CLOSE_PARENTHESIS,
-    );
-
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        $this->acceptedLevelTokens += Tokens::$arithmeticTokens;
-        $this->acceptedLevelTokens += Tokens::$emptyTokens;
-
-        return array(\T_SWITCH);
-    }
-
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        if ($this->supportsAbove('7.3') === false) {
-            return;
-        }
-
-        $tokens = $phpcsFile->getTokens();
-
-        if (isset($tokens[$stackPtr]['scope_opener'], $tokens[$stackPtr]['scope_closer']) === false) {
-            return;
-        }
-
-        $switchOpener = $tokens[$stackPtr]['scope_opener'];
-        $switchCloser = $tokens[$stackPtr]['scope_closer'];
-
-        // Quick check whether we need to bother with the more complex logic.
-        $hasContinue = $phpcsFile->findNext(\T_CONTINUE, ($switchOpener + 1), $switchCloser);
-        if ($hasContinue === false) {
-            return;
-        }
-
-        $caseDefault = $switchOpener;
-
-        do {
-            $caseDefault = $phpcsFile->findNext($this->caseTokens, ($caseDefault + 1), $switchCloser);
-            if ($caseDefault === false) {
-                break;
-            }
-
-            if (isset($tokens[$caseDefault]['scope_opener']) === false) {
-                // Unknown start of the case, skip.
-                continue;
-            }
-
-            $caseOpener      = $tokens[$caseDefault]['scope_opener'];
-            $nextCaseDefault = $phpcsFile->findNext($this->caseTokens, ($caseDefault + 1), $switchCloser);
-            if ($nextCaseDefault === false) {
-                $caseCloser = $switchCloser;
-            } else {
-                $caseCloser = $nextCaseDefault;
-            }
-
-            // Check for unscoped control structures within the case.
-            $controlStructure = $caseOpener;
-            $doCount          = 0;
-            while (($controlStructure = $phpcsFile->findNext($this->loopStructures, ($controlStructure + 1), $caseCloser)) !== false) {
-                if ($tokens[$controlStructure]['code'] === \T_DO) {
-                    $doCount++;
-                }
-
-                if (isset($tokens[$controlStructure]['scope_opener'], $tokens[$controlStructure]['scope_closer']) === false) {
-                    if ($tokens[$controlStructure]['code'] === \T_WHILE && $doCount > 0) {
-                        // While in a do-while construct.
-                        $doCount--;
-                        continue;
-                    }
-
-                    // Control structure without braces found within the case, ignore this case.
-                    continue 2;
-                }
-            }
-
-            // Examine the contents of the case.
-            $continue = $caseOpener;
-
-            do {
-                $continue = $phpcsFile->findNext(\T_CONTINUE, ($continue + 1), $caseCloser);
-                if ($continue === false) {
-                    break;
-                }
-
-                $nextSemicolon = $phpcsFile->findNext(array(\T_SEMICOLON, \T_CLOSE_TAG), ($continue + 1), $caseCloser);
-                $codeString    = '';
-                for ($i = ($continue + 1); $i < $nextSemicolon; $i++) {
-                    if (isset($this->acceptedLevelTokens[$tokens[$i]['code']]) === false) {
-                        // Function call/variable or other token which make numeric level impossible to determine.
-                        continue 2;
-                    }
-
-                    if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true) {
-                        continue;
-                    }
-
-                    $codeString .= $tokens[$i]['content'];
-                }
-
-                $level = null;
-                if ($codeString !== '') {
-                    if (is_numeric($codeString)) {
-                        $level = (int) $codeString;
-                    } else {
-                        // With the above logic, the string can only contain digits and operators, eval!
-                        $level = eval("return ( $codeString );");
-                    }
-                }
-
-                if (isset($level) === false || $level === 0) {
-                    $level = 1;
-                }
-
-                // Examine which control structure is being targeted by the continue statement.
-                if (isset($tokens[$continue]['conditions']) === false) {
-                    continue;
-                }
-
-                $conditions = array_reverse($tokens[$continue]['conditions'], true);
-                // PHPCS adds more structures to the conditions array than we want to take into
-                // consideration, so clean up the array.
-                foreach ($conditions as $tokenPtr => $tokenCode) {
-                    if (isset($this->loopStructures[$tokenCode]) === false) {
-                        unset($conditions[$tokenPtr]);
-                    }
-                }
-
-                $targetCondition = \array_slice($conditions, ($level - 1), 1, true);
-                if (empty($targetCondition)) {
-                    continue;
-                }
-
-                $conditionToken = key($targetCondition);
-                if ($conditionToken === $stackPtr) {
-                    $phpcsFile->addWarning(
-                        "Targeting a 'switch' control structure with a 'continue' statement is strongly discouraged and will throw a warning as of PHP 7.3.",
-                        $continue,
-                        'Found'
-                    );
-                }
-
-            } while ($continue < $caseCloser);
-
-        } while ($caseDefault < $switchCloser);
-    }
+	/**
+	 * Token codes of control structures which can be targeted using continue.
+	 *
+	 * @var array
+	 */
+	protected $loopStructures = array(
+		\T_FOR     => \T_FOR,
+		\T_FOREACH => \T_FOREACH,
+		\T_WHILE   => \T_WHILE,
+		\T_DO      => \T_DO,
+		\T_SWITCH  => \T_SWITCH,
+	);
+
+	/**
+	 * Tokens which start a new case within a switch.
+	 *
+	 * @var array
+	 */
+	protected $caseTokens = array(
+		\T_CASE    => \T_CASE,
+		\T_DEFAULT => \T_DEFAULT,
+	);
+
+	/**
+	 * Token codes which are accepted to determine the level for the continue.
+	 *
+	 * This array is enriched with the arithmetic operators in the register() method.
+	 *
+	 * @var array
+	 */
+	protected $acceptedLevelTokens = array(
+		\T_LNUMBER           => \T_LNUMBER,
+		\T_OPEN_PARENTHESIS  => \T_OPEN_PARENTHESIS,
+		\T_CLOSE_PARENTHESIS => \T_CLOSE_PARENTHESIS,
+	);
+
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		$this->acceptedLevelTokens += Tokens::$arithmeticTokens;
+		$this->acceptedLevelTokens += Tokens::$emptyTokens;
+
+		return array(\T_SWITCH);
+	}
+
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		if ($this->supportsAbove('7.3') === false) {
+			return;
+		}
+
+		$tokens = $phpcsFile->getTokens();
+
+		if (isset($tokens[$stackPtr]['scope_opener'], $tokens[$stackPtr]['scope_closer']) === false) {
+			return;
+		}
+
+		$switchOpener = $tokens[$stackPtr]['scope_opener'];
+		$switchCloser = $tokens[$stackPtr]['scope_closer'];
+
+		// Quick check whether we need to bother with the more complex logic.
+		$hasContinue = $phpcsFile->findNext(\T_CONTINUE, ($switchOpener + 1), $switchCloser);
+		if ($hasContinue === false) {
+			return;
+		}
+
+		$caseDefault = $switchOpener;
+
+		do {
+			$caseDefault = $phpcsFile->findNext($this->caseTokens, ($caseDefault + 1), $switchCloser);
+			if ($caseDefault === false) {
+				break;
+			}
+
+			if (isset($tokens[$caseDefault]['scope_opener']) === false) {
+				// Unknown start of the case, skip.
+				continue;
+			}
+
+			$caseOpener      = $tokens[$caseDefault]['scope_opener'];
+			$nextCaseDefault = $phpcsFile->findNext($this->caseTokens, ($caseDefault + 1), $switchCloser);
+			if ($nextCaseDefault === false) {
+				$caseCloser = $switchCloser;
+			} else {
+				$caseCloser = $nextCaseDefault;
+			}
+
+			// Check for unscoped control structures within the case.
+			$controlStructure = $caseOpener;
+			$doCount          = 0;
+			while (($controlStructure = $phpcsFile->findNext($this->loopStructures, ($controlStructure + 1), $caseCloser)) !== false) {
+				if ($tokens[$controlStructure]['code'] === \T_DO) {
+					$doCount++;
+				}
+
+				if (isset($tokens[$controlStructure]['scope_opener'], $tokens[$controlStructure]['scope_closer']) === false) {
+					if ($tokens[$controlStructure]['code'] === \T_WHILE && $doCount > 0) {
+						// While in a do-while construct.
+						$doCount--;
+						continue;
+					}
+
+					// Control structure without braces found within the case, ignore this case.
+					continue 2;
+				}
+			}
+
+			// Examine the contents of the case.
+			$continue = $caseOpener;
+
+			do {
+				$continue = $phpcsFile->findNext(\T_CONTINUE, ($continue + 1), $caseCloser);
+				if ($continue === false) {
+					break;
+				}
+
+				$nextSemicolon = $phpcsFile->findNext(array(\T_SEMICOLON, \T_CLOSE_TAG), ($continue + 1), $caseCloser);
+				$codeString    = '';
+				for ($i = ($continue + 1); $i < $nextSemicolon; $i++) {
+					if (isset($this->acceptedLevelTokens[$tokens[$i]['code']]) === false) {
+						// Function call/variable or other token which make numeric level impossible to determine.
+						continue 2;
+					}
+
+					if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true) {
+						continue;
+					}
+
+					$codeString .= $tokens[$i]['content'];
+				}
+
+				$level = null;
+				if ($codeString !== '') {
+					if (is_numeric($codeString)) {
+						$level = (int) $codeString;
+					} else {
+						// With the above logic, the string can only contain digits and operators, eval!
+						$level = eval("return ( $codeString );");
+					}
+				}
+
+				if (isset($level) === false || $level === 0) {
+					$level = 1;
+				}
+
+				// Examine which control structure is being targeted by the continue statement.
+				if (isset($tokens[$continue]['conditions']) === false) {
+					continue;
+				}
+
+				$conditions = array_reverse($tokens[$continue]['conditions'], true);
+				// PHPCS adds more structures to the conditions array than we want to take into
+				// consideration, so clean up the array.
+				foreach ($conditions as $tokenPtr => $tokenCode) {
+					if (isset($this->loopStructures[$tokenCode]) === false) {
+						unset($conditions[$tokenPtr]);
+					}
+				}
+
+				$targetCondition = \array_slice($conditions, ($level - 1), 1, true);
+				if (empty($targetCondition)) {
+					continue;
+				}
+
+				$conditionToken = key($targetCondition);
+				if ($conditionToken === $stackPtr) {
+					$phpcsFile->addWarning(
+						"Targeting a 'switch' control structure with a 'continue' statement is strongly discouraged and will throw a warning as of PHP 7.3.",
+						$continue,
+						'Found'
+					);
+				}
+
+			} while ($continue < $caseCloser);
+
+		} while ($caseDefault < $switchCloser);
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/ControlStructures/ForbiddenBreakContinueVariableArgumentsSniff.php

Indentation +61 added lines, -61 removed lines

@@ -30,72 +30,72 @@
  */
 class ForbiddenBreakContinueVariableArgumentsSniff extends Sniff
 {
-    /**
-     * Error types this sniff handles for forbidden break/continue arguments.
-     *
-     * Array key is the error code. Array value will be used as part of the error message.
-     *
-     * @var array
-     */
-    private $errorTypes = array(
-        'variableArgument' => 'a variable argument',
-        'zeroArgument'     => '0 as an argument',
-    );
+	/**
+	 * Error types this sniff handles for forbidden break/continue arguments.
+	 *
+	 * Array key is the error code. Array value will be used as part of the error message.
+	 *
+	 * @var array
+	 */
+	private $errorTypes = array(
+		'variableArgument' => 'a variable argument',
+		'zeroArgument'     => '0 as an argument',
+	);
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return array(\T_BREAK, \T_CONTINUE);
-    }
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return array(\T_BREAK, \T_CONTINUE);
+	}
 
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        if ($this->supportsAbove('5.4') === false) {
-            return;
-        }
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		if ($this->supportsAbove('5.4') === false) {
+			return;
+		}
 
-        $tokens             = $phpcsFile->getTokens();
-        $nextSemicolonToken = $phpcsFile->findNext(array(\T_SEMICOLON, \T_CLOSE_TAG), ($stackPtr), null, false);
-        $errorType          = '';
-        for ($curToken = $stackPtr + 1; $curToken < $nextSemicolonToken; $curToken++) {
-            if ($tokens[$curToken]['type'] === 'T_STRING') {
-                // If the next non-whitespace token after the string
-                // is an opening parenthesis then it's a function call.
-                $openBracket = $phpcsFile->findNext(Tokens::$emptyTokens, $curToken + 1, null, true);
-                if ($tokens[$openBracket]['code'] === \T_OPEN_PARENTHESIS) {
-                    $errorType = 'variableArgument';
-                    break;
-                }
+		$tokens             = $phpcsFile->getTokens();
+		$nextSemicolonToken = $phpcsFile->findNext(array(\T_SEMICOLON, \T_CLOSE_TAG), ($stackPtr), null, false);
+		$errorType          = '';
+		for ($curToken = $stackPtr + 1; $curToken < $nextSemicolonToken; $curToken++) {
+			if ($tokens[$curToken]['type'] === 'T_STRING') {
+				// If the next non-whitespace token after the string
+				// is an opening parenthesis then it's a function call.
+				$openBracket = $phpcsFile->findNext(Tokens::$emptyTokens, $curToken + 1, null, true);
+				if ($tokens[$openBracket]['code'] === \T_OPEN_PARENTHESIS) {
+					$errorType = 'variableArgument';
+					break;
+				}
 
-            } elseif (\in_array($tokens[$curToken]['type'], array('T_VARIABLE', 'T_FUNCTION', 'T_CLOSURE'), true)) {
-                $errorType = 'variableArgument';
-                break;
+			} elseif (\in_array($tokens[$curToken]['type'], array('T_VARIABLE', 'T_FUNCTION', 'T_CLOSURE'), true)) {
+				$errorType = 'variableArgument';
+				break;
 
-            } elseif ($tokens[$curToken]['type'] === 'T_LNUMBER' && $tokens[$curToken]['content'] === '0') {
-                $errorType = 'zeroArgument';
-                break;
-            }
-        }
+			} elseif ($tokens[$curToken]['type'] === 'T_LNUMBER' && $tokens[$curToken]['content'] === '0') {
+				$errorType = 'zeroArgument';
+				break;
+			}
+		}
 
-        if ($errorType !== '') {
-            $error     = 'Using %s on break or continue is forbidden since PHP 5.4';
-            $errorCode = $errorType . 'Found';
-            $data      = array($this->errorTypes[$errorType]);
+		if ($errorType !== '') {
+			$error     = 'Using %s on break or continue is forbidden since PHP 5.4';
+			$errorCode = $errorType . 'Found';
+			$data      = array($this->errorTypes[$errorType]);
 
-            $phpcsFile->addError($error, $stackPtr, $errorCode, $data);
-        }
-    }
+			$phpcsFile->addError($error, $stackPtr, $errorCode, $data);
+		}
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/ControlStructures/ForbiddenSwitchWithMultipleDefaultBlocksSniff.php

Indentation +44 added lines, -44 removed lines

@@ -28,52 +28,52 @@
 class ForbiddenSwitchWithMultipleDefaultBlocksSniff extends Sniff
 {
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return array(\T_SWITCH);
-    }
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return array(\T_SWITCH);
+	}
 
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        if ($this->supportsAbove('7.0') === false) {
-            return;
-        }
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		if ($this->supportsAbove('7.0') === false) {
+			return;
+		}
 
-        $tokens = $phpcsFile->getTokens();
-        if (isset($tokens[$stackPtr]['scope_closer']) === false) {
-            return;
-        }
+		$tokens = $phpcsFile->getTokens();
+		if (isset($tokens[$stackPtr]['scope_closer']) === false) {
+			return;
+		}
 
-        $defaultToken = $stackPtr;
-        $defaultCount = 0;
-        $targetLevel  = $tokens[$stackPtr]['level'] + 1;
-        while ($defaultCount < 2 && ($defaultToken = $phpcsFile->findNext(array(\T_DEFAULT), $defaultToken + 1, $tokens[$stackPtr]['scope_closer'])) !== false) {
-            // Same level or one below (= two default cases after each other).
-            if ($tokens[$defaultToken]['level'] === $targetLevel || $tokens[$defaultToken]['level'] === ($targetLevel + 1)) {
-                $defaultCount++;
-            }
-        }
+		$defaultToken = $stackPtr;
+		$defaultCount = 0;
+		$targetLevel  = $tokens[$stackPtr]['level'] + 1;
+		while ($defaultCount < 2 && ($defaultToken = $phpcsFile->findNext(array(\T_DEFAULT), $defaultToken + 1, $tokens[$stackPtr]['scope_closer'])) !== false) {
+			// Same level or one below (= two default cases after each other).
+			if ($tokens[$defaultToken]['level'] === $targetLevel || $tokens[$defaultToken]['level'] === ($targetLevel + 1)) {
+				$defaultCount++;
+			}
+		}
 
-        if ($defaultCount > 1) {
-            $phpcsFile->addError(
-                'Switch statements can not have multiple default blocks since PHP 7.0',
-                $stackPtr,
-                'Found'
-            );
-        }
-    }
+		if ($defaultCount > 1) {
+			$phpcsFile->addError(
+				'Switch statements can not have multiple default blocks since PHP 7.0',
+				$stackPtr,
+				'Found'
+			);
+		}
+	}
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/ControlStructures/ForbiddenBreakContinueOutsideLoopSniff.php

Indentation +71 added lines, -71 removed lines

@@ -28,82 +28,82 @@
 class ForbiddenBreakContinueOutsideLoopSniff extends Sniff
 {
 
-    /**
-     * Token codes of control structure in which usage of break/continue is valid.
-     *
-     * @var array
-     */
-    protected $validLoopStructures = array(
-        \T_FOR     => true,
-        \T_FOREACH => true,
-        \T_WHILE   => true,
-        \T_DO      => true,
-        \T_SWITCH  => true,
-    );
+	/**
+	 * Token codes of control structure in which usage of break/continue is valid.
+	 *
+	 * @var array
+	 */
+	protected $validLoopStructures = array(
+		\T_FOR     => true,
+		\T_FOREACH => true,
+		\T_WHILE   => true,
+		\T_DO      => true,
+		\T_SWITCH  => true,
+	);
 
-    /**
-     * Token codes which did not correctly get a condition assigned in older PHPCS versions.
-     *
-     * @var array
-     */
-    protected $backCompat = array(
-        \T_CASE    => true,
-        \T_DEFAULT => true,
-    );
+	/**
+	 * Token codes which did not correctly get a condition assigned in older PHPCS versions.
+	 *
+	 * @var array
+	 */
+	protected $backCompat = array(
+		\T_CASE    => true,
+		\T_DEFAULT => true,
+	);
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return array(
-            \T_BREAK,
-            \T_CONTINUE,
-        );
-    }
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return array(
+			\T_BREAK,
+			\T_CONTINUE,
+		);
+	}
 
-    /**
-     * 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(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-        $token  = $tokens[$stackPtr];
+	/**
+	 * 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(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+		$token  = $tokens[$stackPtr];
 
-        // Check if the break/continue is within a valid loop structure.
-        if (empty($token['conditions']) === false) {
-            foreach ($token['conditions'] as $tokenCode) {
-                if (isset($this->validLoopStructures[$tokenCode]) === true) {
-                    return;
-                }
-            }
-        } else {
-            // Deal with older PHPCS versions.
-            if (isset($token['scope_condition']) === true && isset($this->backCompat[$tokens[$token['scope_condition']]['code']]) === true) {
-                return;
-            }
-        }
+		// Check if the break/continue is within a valid loop structure.
+		if (empty($token['conditions']) === false) {
+			foreach ($token['conditions'] as $tokenCode) {
+				if (isset($this->validLoopStructures[$tokenCode]) === true) {
+					return;
+				}
+			}
+		} else {
+			// Deal with older PHPCS versions.
+			if (isset($token['scope_condition']) === true && isset($this->backCompat[$tokens[$token['scope_condition']]['code']]) === true) {
+				return;
+			}
+		}
 
-        // If we're still here, no valid loop structure container has been found, so throw an error.
-        $error     = "Using '%s' outside of a loop or switch structure is invalid";
-        $isError   = false;
-        $errorCode = 'Found';
-        $data      = array($token['content']);
+		// If we're still here, no valid loop structure container has been found, so throw an error.
+		$error     = "Using '%s' outside of a loop or switch structure is invalid";
+		$isError   = false;
+		$errorCode = 'Found';
+		$data      = array($token['content']);
 
-        if ($this->supportsAbove('7.0')) {
-            $error    .= ' and will throw a fatal error since PHP 7.0';
-            $isError   = true;
-            $errorCode = 'FatalError';
-        }
+		if ($this->supportsAbove('7.0')) {
+			$error    .= ' and will throw a fatal error since PHP 7.0';
+			$isError   = true;
+			$errorCode = 'FatalError';
+		}
 
-        $this->addMessage($phpcsFile, $error, $stackPtr, $isError, $errorCode, $data);
-    }
+		$this->addMessage($phpcsFile, $error, $stackPtr, $isError, $errorCode, $data);
+	}
 }