function FunctionCallArgumentSpacingSniff::checkSpacing

Checks the spacing around commas.

Parameters

\PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.:

int $stackPtr The position of the current token in the: stack passed in $tokens.

int $openBracket The position of the opening bracket: in the stack passed in $tokens.

Return value

void

1 call to FunctionCallArgumentSpacingSniff::checkSpacing()

FunctionCallArgumentSpacingSniff::process in vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/Functions/FunctionCallArgumentSpacingSniff.php

Processes this test, when one of its tokens is encountered.

File

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/Functions/FunctionCallArgumentSpacingSniff.php, line 102

Class

FunctionCallArgumentSpacingSniff

Namespace

PHP_CodeSniffer\Standards\Generic\Sniffs\Functions

Code

public function checkSpacing(File $phpcsFile, $stackPtr, $openBracket) {
    $tokens = $phpcsFile->getTokens();
    $closeBracket = $tokens[$openBracket]['parenthesis_closer'];
    $nextSeparator = $openBracket;
    $find = [
        T_COMMA,
        T_CLOSURE,
        T_FN,
        T_ANON_CLASS,
        T_OPEN_SHORT_ARRAY,
        T_MATCH,
    ];
    while (($nextSeparator = $phpcsFile->findNext($find, $nextSeparator + 1, $closeBracket)) !== false) {
        if ($tokens[$nextSeparator]['code'] === T_CLOSURE || $tokens[$nextSeparator]['code'] === T_ANON_CLASS || $tokens[$nextSeparator]['code'] === T_MATCH) {
            // Skip closures, anon class declarations and match control structures.
            $nextSeparator = $tokens[$nextSeparator]['scope_closer'];
            continue;
        }
        else {
            if ($tokens[$nextSeparator]['code'] === T_FN) {
                // Skip arrow functions, but don't skip the arrow function closer as it is likely to
                // be the comma separating it from the next function call argument (or the parenthesis closer).
                $nextSeparator = $tokens[$nextSeparator]['scope_closer'] - 1;
                continue;
            }
            else {
                if ($tokens[$nextSeparator]['code'] === T_OPEN_SHORT_ARRAY) {
                    // Skips arrays using short notation.
                    $nextSeparator = $tokens[$nextSeparator]['bracket_closer'];
                    continue;
                }
            }
        }
        // Make sure the comma or variable belongs directly to this function call,
        // and is not inside a nested function call or array.
        $brackets = $tokens[$nextSeparator]['nested_parenthesis'];
        $lastBracket = array_pop($brackets);
        if ($lastBracket !== $closeBracket) {
            continue;
        }
        if ($tokens[$nextSeparator]['code'] === T_COMMA) {
            if ($tokens[$nextSeparator - 1]['code'] === T_WHITESPACE) {
                $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, $nextSeparator - 2, null, true);
                if (isset(Tokens::$heredocTokens[$tokens[$prev]['code']]) === false) {
                    $error = 'Space found before comma in argument list';
                    $fix = $phpcsFile->addFixableError($error, $nextSeparator, 'SpaceBeforeComma');
                    if ($fix === true) {
                        $phpcsFile->fixer
                            ->beginChangeset();
                        if ($tokens[$prev]['line'] !== $tokens[$nextSeparator]['line']) {
                            $phpcsFile->fixer
                                ->addContent($prev, ',');
                            $phpcsFile->fixer
                                ->replaceToken($nextSeparator, '');
                        }
                        else {
                            $phpcsFile->fixer
                                ->replaceToken($nextSeparator - 1, '');
                        }
                        $phpcsFile->fixer
                            ->endChangeset();
                    }
                }
                
                //end if
            }
            
            //end if
            if ($tokens[$nextSeparator + 1]['code'] !== T_WHITESPACE) {
                // Ignore trailing comma's after last argument as that's outside the scope of this sniff.
                if ($nextSeparator + 1 !== $closeBracket) {
                    $error = 'No space found after comma in argument list';
                    $fix = $phpcsFile->addFixableError($error, $nextSeparator, 'NoSpaceAfterComma');
                    if ($fix === true) {
                        $phpcsFile->fixer
                            ->addContent($nextSeparator, ' ');
                    }
                }
            }
            else {
                // If there is a newline in the space, then they must be formatting
                // each argument on a newline, which is valid, so ignore it.
                $next = $phpcsFile->findNext(Tokens::$emptyTokens, $nextSeparator + 1, null, true);
                if ($tokens[$next]['line'] === $tokens[$nextSeparator]['line']) {
                    $space = $tokens[$nextSeparator + 1]['length'];
                    if ($space > 1) {
                        $error = 'Expected 1 space after comma in argument list; %s found';
                        $data = [
                            $space,
                        ];
                        $fix = $phpcsFile->addFixableError($error, $nextSeparator, 'TooMuchSpaceAfterComma', $data);
                        if ($fix === true) {
                            $phpcsFile->fixer
                                ->replaceToken($nextSeparator + 1, ' ');
                        }
                    }
                }
            }
            
            //end if
        }
        
        //end if
    }
    
    //end while
}