function UselessParenthesesSniff::checkParenthesesAroundOperators

1 call to UselessParenthesesSniff::checkParenthesesAroundOperators()

UselessParenthesesSniff::process in vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/PHP/UselessParenthesesSniff.php

* @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint *

File

vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/PHP/UselessParenthesesSniff.php, line 450

Class

UselessParenthesesSniff

Namespace

SlevomatCodingStandard\Sniffs\PHP

Code

private function checkParenthesesAroundOperators(File $phpcsFile, int $parenthesisOpenerPointer) : void {
    $tokens = $phpcsFile->getTokens();
    $pointerBeforeParenthesisOpener = TokenHelper::findPreviousEffective($phpcsFile, $parenthesisOpenerPointer - 1);
    $pointerAfterParenthesisCloser = TokenHelper::findNextEffective($phpcsFile, $tokens[$parenthesisOpenerPointer]['parenthesis_closer'] + 1);
    if ($tokens[$pointerBeforeParenthesisOpener]['code'] === T_MINUS) {
        $pointerBeforeMinus = TokenHelper::findPreviousEffective($phpcsFile, $pointerBeforeParenthesisOpener - 1);
        if (!in_array($tokens[$pointerBeforeMinus]['code'], [
            T_DNUMBER,
            T_LNUMBER,
        ], true)) {
            return;
        }
    }
    if (in_array($tokens[$pointerBeforeParenthesisOpener]['code'], Tokens::$booleanOperators, true) || in_array($tokens[$pointerAfterParenthesisCloser]['code'], Tokens::$booleanOperators, true)) {
        return;
    }
    $operatorsPointers = [];
    $actualStartPointer = $parenthesisOpenerPointer + 1;
    while (true) {
        $pointer = TokenHelper::findNext($phpcsFile, array_merge(self::OPERATORS, [
            T_OPEN_PARENTHESIS,
            T_INLINE_THEN,
            T_COALESCE,
            T_BITWISE_AND,
            T_BITWISE_OR,
            T_BITWISE_XOR,
        ], Tokens::$comparisonTokens), $actualStartPointer, $tokens[$parenthesisOpenerPointer]['parenthesis_closer']);
        if ($pointer === null) {
            break;
        }
        if (in_array($tokens[$pointer]['code'], [
            T_INLINE_THEN,
            T_COALESCE,
            T_BITWISE_AND,
            T_BITWISE_OR,
            T_BITWISE_XOR,
        ], true)) {
            return;
        }
        if (in_array($tokens[$pointer]['code'], Tokens::$comparisonTokens, true)) {
            return;
        }
        if ($tokens[$pointer]['code'] === T_OPEN_PARENTHESIS) {
            $actualStartPointer = $tokens[$pointer]['parenthesis_closer'] + 1;
            continue;
        }
        $operatorsPointers[] = $pointer;
        $actualStartPointer = $pointer + 1;
    }
    if (count($operatorsPointers) === 0) {
        return;
    }
    if ($tokens[$pointerBeforeParenthesisOpener]['code'] !== T_EQUAL || $tokens[$pointerAfterParenthesisCloser]['code'] !== T_SEMICOLON) {
        $operatorsGroups = array_map(static function (int $operatorPointer) use ($tokens) : int {
            return self::OPERATOR_GROUPS[$tokens[$operatorPointer]['code']];
        }, $operatorsPointers);
        if (count($operatorsGroups) > 1) {
            return;
        }
    }
    $firstOperatorPointer = $operatorsPointers[0];
    if (in_array($tokens[$pointerBeforeParenthesisOpener]['code'], self::OPERATORS, true)) {
        if (self::OPERATOR_GROUPS[$tokens[$firstOperatorPointer]['code']] !== self::OPERATOR_GROUPS[$tokens[$pointerBeforeParenthesisOpener]['code']]) {
            return;
        }
        if ($tokens[$pointerBeforeParenthesisOpener]['code'] === T_MINUS && in_array($tokens[$firstOperatorPointer]['code'], [
            T_PLUS,
            T_MINUS,
        ], true)) {
            return;
        }
        if ($tokens[$pointerBeforeParenthesisOpener]['code'] === T_DIVIDE && in_array($tokens[$firstOperatorPointer]['code'], [
            T_DIVIDE,
            T_MULTIPLY,
        ], true)) {
            return;
        }
        if ($tokens[$pointerBeforeParenthesisOpener]['code'] === T_MODULUS && $tokens[$firstOperatorPointer]['code'] === T_MODULUS) {
            return;
        }
    }
    $lastOperatorPointer = $operatorsPointers[count($operatorsPointers) - 1];
    if (in_array($tokens[$pointerAfterParenthesisCloser]['code'], self::OPERATORS, true) && self::OPERATOR_GROUPS[$tokens[$lastOperatorPointer]['code']] !== self::OPERATOR_GROUPS[$tokens[$pointerAfterParenthesisCloser]['code']]) {
        return;
    }
    $fix = $phpcsFile->addFixableError('Useless parentheses.', $parenthesisOpenerPointer, self::CODE_USELESS_PARENTHESES);
    if (!$fix) {
        return;
    }
    $contentStartPointer = TokenHelper::findNextEffective($phpcsFile, $parenthesisOpenerPointer + 1);
    $contentEndPointer = TokenHelper::findPreviousEffective($phpcsFile, $tokens[$parenthesisOpenerPointer]['parenthesis_closer'] - 1);
    $phpcsFile->fixer
        ->beginChangeset();
    FixerHelper::removeBetweenIncluding($phpcsFile, $parenthesisOpenerPointer, $contentStartPointer - 1);
    FixerHelper::removeBetweenIncluding($phpcsFile, $contentEndPointer + 1, $tokens[$parenthesisOpenerPointer]['parenthesis_closer']);
    $phpcsFile->fixer
        ->endChangeset();
}