18051010410

Committed 26 Sep 2025 10:40PM UTC coverage: 94.308% (-0.02%) from 94.331%

Build # 18051010410

Build Type

push

github

Committed by

web-flow

Commit Message

chore: use accidentally missing `@auto:risky` (#9102)

Run Details

28583 of 30308 relevant lines covered (94.31%)

45.24 hits per line

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

99.16

/src/Fixer/FunctionNotation/MethodArgumentSpaceFixer.php

<?php

declare(strict_types=1);

/*
 * This file is part of PHP CS Fixer.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace PhpCsFixer\Fixer\FunctionNotation;

use PhpCsFixer\AbstractFixer;
use PhpCsFixer\Fixer\ConfigurableFixerInterface;
use PhpCsFixer\Fixer\ConfigurableFixerTrait;
use PhpCsFixer\Fixer\WhitespacesAwareFixerInterface;
use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
use PhpCsFixer\FixerDefinition\CodeSample;
use PhpCsFixer\FixerDefinition\FixerDefinition;
use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
use PhpCsFixer\Future;
use PhpCsFixer\Preg;
use PhpCsFixer\Tokenizer\CT;
use PhpCsFixer\Tokenizer\Token;
use PhpCsFixer\Tokenizer\Tokens;

/**
 * @phpstan-type _AutogeneratedInputConfiguration array{
 *  after_heredoc?: bool,
 *  attribute_placement?: 'ignore'|'same_line'|'standalone',
 *  keep_multiple_spaces_after_comma?: bool,
 *  on_multiline?: 'ensure_fully_multiline'|'ensure_single_line'|'ignore',
 * }
 * @phpstan-type _AutogeneratedComputedConfiguration array{
 *  after_heredoc: bool,
 *  attribute_placement: 'ignore'|'same_line'|'standalone',
 *  keep_multiple_spaces_after_comma: bool,
 *  on_multiline: 'ensure_fully_multiline'|'ensure_single_line'|'ignore',
 * }
 *
 * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
 *
 * @author Kuanhung Chen <ericj.tw@gmail.com>
 *
 * @no-named-arguments Parameter names are not covered by the backward compatibility promise.
 */
final class MethodArgumentSpaceFixer extends AbstractFixer implements ConfigurableFixerInterface, WhitespacesAwareFixerInterface
{
    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
    use ConfigurableFixerTrait;

    public function getDefinition(): FixerDefinitionInterface
    {
        return new FixerDefinition(
            'In method arguments and method call, there MUST NOT be a space before each comma and there MUST be one space after each comma. Argument lists MAY be split across multiple lines, where each subsequent line is indented once. When doing so, the first item in the list MUST be on the next line, and there MUST be only one argument per line.',
            [
                new CodeSample(
                    "<?php\nfunction sample(\$a=10,\$b=20,\$c=30) {}\nsample(1,  2);\n",
                    null
                ),
                new CodeSample(
                    "<?php\nfunction sample(\$a=10,\$b=20,\$c=30) {}\nsample(1,  2);\n",
                    ['keep_multiple_spaces_after_comma' => false]
                ),
                new CodeSample(
                    "<?php\nfunction sample(\$a=10,\$b=20,\$c=30) {}\nsample(1,  2);\n",
                    ['keep_multiple_spaces_after_comma' => true]
                ),
                new CodeSample(
                    "<?php\nfunction sample(\$a=10,\n    \$b=20,\$c=30) {}\nsample(1,\n    2);\n",
                    ['on_multiline' => 'ensure_fully_multiline']
                ),
                new CodeSample(
                    "<?php\nfunction sample(\n    \$a=10,\n    \$b=20,\n    \$c=30\n) {}\nsample(\n    1,\n    2\n);\n",
                    ['on_multiline' => 'ensure_single_line']
                ),
                new CodeSample(
                    "<?php\nfunction sample(\$a=10,\n    \$b=20,\$c=30) {}\nsample(1,  \n    2);\nsample('foo',    'foobarbaz', 'baz');\nsample('foobar', 'bar',       'baz');\n",
                    [
                        'on_multiline' => 'ensure_fully_multiline',
                        'keep_multiple_spaces_after_comma' => true,
                    ]
                ),
                new CodeSample(
                    "<?php\nfunction sample(\$a=10,\n    \$b=20,\$c=30) {}\nsample(1,  \n    2);\nsample('foo',    'foobarbaz', 'baz');\nsample('foobar', 'bar',       'baz');\n",
                    [
                        'on_multiline' => 'ensure_fully_multiline',
                        'keep_multiple_spaces_after_comma' => false,
                    ]
                ),
                new CodeSample(
                    "<?php\nfunction sample(#[Foo] #[Bar] \$a=10,\n    \$b=20,\$c=30) {}\nsample(1,  2);\n",
                    [
                        'on_multiline' => 'ensure_fully_multiline',
                        'attribute_placement' => 'ignore',
                    ]
                ),
                new CodeSample(
                    "<?php\nfunction sample(#[Foo]\n    #[Bar]\n    \$a=10,\n    \$b=20,\$c=30) {}\nsample(1,  2);\n",
                    [
                        'on_multiline' => 'ensure_fully_multiline',
                        'attribute_placement' => 'same_line',
                    ]
                ),
                new CodeSample(
                    "<?php\nfunction sample(#[Foo] #[Bar] \$a=10,\n    \$b=20,\$c=30) {}\nsample(1,  2);\n",
                    [
                        'on_multiline' => 'ensure_fully_multiline',
                        'attribute_placement' => 'standalone',
                    ]
                ),
                new CodeSample(
                    <<<'SAMPLE'
                        <?php
                        sample(
                            <<<EOD
                                foo
                                EOD
                            ,
                            'bar'
                        );

                        SAMPLE,
                    ['after_heredoc' => true]
                ),
            ],
            'This fixer covers rules defined in PSR2 ¶4.4, ¶4.6.'
        );
    }

    public function isCandidate(Tokens $tokens): bool
    {
        return $tokens->isTokenKindFound('(');
    }

    /**
     * {@inheritdoc}
     *
     * Must run before ArrayIndentationFixer, StatementIndentationFixer.
     * Must run after CombineNestedDirnameFixer, FunctionDeclarationFixer, ImplodeCallFixer, LambdaNotUsedImportFixer, NoMultilineWhitespaceAroundDoubleArrowFixer, NoUselessSprintfFixer, PowToExponentiationFixer, StrictParamFixer.
     */
    public function getPriority(): int
    {
        return 30;
    }

    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
    {
        $expectedTokens = [\T_LIST, \T_FUNCTION, CT::T_USE_LAMBDA, \T_FN, \T_CLASS];

        $tokenCount = $tokens->count();
        for ($index = 1; $index < $tokenCount; ++$index) {
            $token = $tokens[$index];

            if (!$token->equals('(')) {
                continue;
            }

            $meaningfulTokenBeforeParenthesis = $tokens[$tokens->getPrevMeaningfulToken($index)];

            if (
                $meaningfulTokenBeforeParenthesis->isKeyword()
                && !$meaningfulTokenBeforeParenthesis->isGivenKind($expectedTokens)
            ) {
                continue;
            }

            $isMultiline = $this->fixFunction($tokens, $index);

            if (
                $isMultiline
                && 'ensure_fully_multiline' === $this->configuration['on_multiline']
                && !$meaningfulTokenBeforeParenthesis->isGivenKind(\T_LIST)
            ) {
                $this->ensureFunctionFullyMultiline($tokens, $index);
            }
        }
    }

    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
    {
        return new FixerConfigurationResolver([
            (new FixerOptionBuilder('keep_multiple_spaces_after_comma', 'Whether keep multiple spaces after comma.'))
                ->setAllowedTypes(['bool'])
                ->setDefault(false)
                ->getOption(),
            (new FixerOptionBuilder(
                'on_multiline',
                'Defines how to handle function arguments lists that contain newlines.'
            ))
                ->setAllowedValues(['ignore', 'ensure_single_line', 'ensure_fully_multiline'])
                ->setDefault('ensure_fully_multiline')
                ->getOption(),
            (new FixerOptionBuilder('after_heredoc', 'Whether the whitespace between heredoc end and comma should be removed.'))
                ->setAllowedTypes(['bool'])
                ->setDefault(Future::getV4OrV3(true, false))
                ->getOption(),
            (new FixerOptionBuilder(
                'attribute_placement',
                'Defines how to handle argument attributes when function definition is multiline.'
            ))
                ->setAllowedValues(['ignore', 'same_line', 'standalone'])
                ->setDefault('standalone')
                ->getOption(),
        ]);
    }

    /**
     * Fix arguments spacing for given function.
     *
     * @param Tokens $tokens             Tokens to handle
     * @param int    $startFunctionIndex Start parenthesis position
     *
     * @return bool whether the function is multiline
     */
    private function fixFunction(Tokens $tokens, int $startFunctionIndex): bool
    {
        $isMultiline = false;

        $endFunctionIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startFunctionIndex);
        $firstWhitespaceIndex = $this->findWhitespaceIndexAfterParenthesis($tokens, $startFunctionIndex, $endFunctionIndex);
        $lastWhitespaceIndex = $this->findWhitespaceIndexAfterParenthesis($tokens, $endFunctionIndex, $startFunctionIndex);

        foreach ([$firstWhitespaceIndex, $lastWhitespaceIndex] as $index) {
            if (null === $index || !Preg::match('/\R/', $tokens[$index]->getContent())) {
                continue;
            }

            if ('ensure_single_line' !== $this->configuration['on_multiline']) {
                $isMultiline = true;

                continue;
            }

            $newLinesRemoved = $this->ensureSingleLine($tokens, $index);

            if (!$newLinesRemoved) {
                $isMultiline = true;
            }
        }

        for ($index = $endFunctionIndex - 1; $index > $startFunctionIndex; --$index) {
            $token = $tokens[$index];

            if ($token->equals(')')) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);

                continue;
            }

            if ($token->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_CLOSE)) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $index);

                continue;
            }

            if ($token->equals('}')) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);

                continue;
            }

            if ($token->equals(',')) {
                $this->fixSpace($tokens, $index);
                if (!$isMultiline && $this->isNewline($tokens[$index + 1])) {
                    $isMultiline = true;
                }
            }
        }

        return $isMultiline;
    }

    private function findWhitespaceIndexAfterParenthesis(Tokens $tokens, int $startParenthesisIndex, int $endParenthesisIndex): ?int
    {
        $direction = $endParenthesisIndex > $startParenthesisIndex ? 1 : -1;
        $startIndex = $startParenthesisIndex + $direction;
        $endIndex = $endParenthesisIndex - $direction;

        for ($index = $startIndex; $index !== $endIndex; $index += $direction) {
            $token = $tokens[$index];

            if ($token->isWhitespace()) {
                return $index;
            }

            if (!$token->isComment()) {
                break;
            }
        }

        return null;
    }

    /**
     * @return bool Whether newlines were removed from the whitespace token
     */
    private function ensureSingleLine(Tokens $tokens, int $index): bool
    {
        $previousToken = $tokens[$index - 1];

        if ($previousToken->isComment() && !str_starts_with($previousToken->getContent(), '/*')) {
            return false;
        }

        $content = Preg::replace('/\R\h*/', '', $tokens[$index]->getContent());

        $tokens->ensureWhitespaceAtIndex($index, 0, $content);

        return true;
    }

    private function ensureFunctionFullyMultiline(Tokens $tokens, int $startFunctionIndex): void
    {
        // find out what the indentation is
        $searchIndex = $startFunctionIndex;
        do {
            $prevWhitespaceTokenIndex = $tokens->getPrevTokenOfKind(
                $searchIndex,
                [[\T_ENCAPSED_AND_WHITESPACE], [\T_INLINE_HTML], [\T_WHITESPACE]],
            );

            $searchIndex = $prevWhitespaceTokenIndex;
        } while (null !== $prevWhitespaceTokenIndex
            && !str_contains($tokens[$prevWhitespaceTokenIndex]->getContent(), "\n")
        );

        if (null === $prevWhitespaceTokenIndex) {
            $existingIndentation = '';
        } elseif (!$tokens[$prevWhitespaceTokenIndex]->isGivenKind(\T_WHITESPACE)) {
            return;
        } else {
            $existingIndentation = $tokens[$prevWhitespaceTokenIndex]->getContent();
            $lastLineIndex = strrpos($existingIndentation, "\n");
            $existingIndentation = false === $lastLineIndex
                ? $existingIndentation
                : substr($existingIndentation, $lastLineIndex + 1);
        }

        $indentation = $existingIndentation.$this->whitespacesConfig->getIndent();
        $endFunctionIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startFunctionIndex);

        $wasWhitespaceBeforeEndFunctionAddedAsNewToken = $tokens->ensureWhitespaceAtIndex(
            $tokens[$endFunctionIndex - 1]->isWhitespace() ? $endFunctionIndex - 1 : $endFunctionIndex,
            0,
            $this->whitespacesConfig->getLineEnding().$existingIndentation
        );

        if ($wasWhitespaceBeforeEndFunctionAddedAsNewToken) {
            ++$endFunctionIndex;
        }

        for ($index = $endFunctionIndex - 1; $index > $startFunctionIndex; --$index) {
            $token = $tokens[$index];

            // skip nested method calls and arrays
            if ($token->equals(')')) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);

                continue;
            }

            // skip nested arrays
            if ($token->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_CLOSE)) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $index);

                continue;
            }

            if ($token->equals('}')) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);

                continue;
            }

            if ($tokens[$tokens->getNextMeaningfulToken($index)]->equals(')')) {
                continue;
            }

            if ($token->isGivenKind(CT::T_ATTRIBUTE_CLOSE)) {
                if ('standalone' === $this->configuration['attribute_placement']) {
                    $this->fixNewline($tokens, $index, $indentation);
                } elseif ('same_line' === $this->configuration['attribute_placement']) {
                    $this->ensureSingleLine($tokens, $index + 1);
                    $tokens->ensureWhitespaceAtIndex($index + 1, 0, ' ');
                }
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ATTRIBUTE, $index);

                continue;
            }

            if ($token->equals(',')) {
                $this->fixNewline($tokens, $index, $indentation);
            }
        }

        $this->fixNewline($tokens, $startFunctionIndex, $indentation, false);
    }

    /**
     * Method to insert newline after comma, attribute or opening parenthesis.
     *
     * @param int    $index       index of a comma
     * @param string $indentation the indentation that should be used
     * @param bool   $override    whether to override the existing character or not
     */
    private function fixNewline(Tokens $tokens, int $index, string $indentation, bool $override = true): void
    {
        if ($tokens[$index + 1]->isComment()) {
            return;
        }

        if ($tokens[$index + 2]->isComment()) {
            $nextMeaningfulTokenIndex = $tokens->getNextMeaningfulToken($index + 2);
            if (!$this->isNewline($tokens[$nextMeaningfulTokenIndex - 1])) {
                if ($tokens[$nextMeaningfulTokenIndex - 1]->isWhitespace()) {
                    $tokens->clearAt($nextMeaningfulTokenIndex - 1);
                }

                $tokens->ensureWhitespaceAtIndex($nextMeaningfulTokenIndex, 0, $this->whitespacesConfig->getLineEnding().$indentation);
            }

            return;
        }

        $nextMeaningfulTokenIndex = $tokens->getNextMeaningfulToken($index);

        if ($tokens[$nextMeaningfulTokenIndex]->equals(')')) {
            return;
        }

        $tokens->ensureWhitespaceAtIndex($index + 1, 0, $this->whitespacesConfig->getLineEnding().$indentation);
    }

    /**
     * Method to insert space after comma and remove space before comma.
     */
    private function fixSpace(Tokens $tokens, int $index): void
    {
        // remove space before comma if exist
        if ($tokens[$index - 1]->isWhitespace()) {
            $prevIndex = $tokens->getPrevNonWhitespace($index - 1);

            if (
                !$tokens[$prevIndex]->equals(',') && !$tokens[$prevIndex]->isComment()
                && (true === $this->configuration['after_heredoc'] || !$tokens[$prevIndex]->isGivenKind(\T_END_HEREDOC))
            ) {
                $tokens->clearAt($index - 1);
            }
        }

        $nextIndex = $index + 1;
        $nextToken = $tokens[$nextIndex];

        // Two cases for fix space after comma (exclude multiline comments)
        //  1) multiple spaces after comma
        //  2) no space after comma
        if ($nextToken->isWhitespace()) {
            $newContent = $nextToken->getContent();

            if ('ensure_single_line' === $this->configuration['on_multiline']) {
                $newContent = Preg::replace('/\R/', '', $newContent);
            }

            if (
                (false === $this->configuration['keep_multiple_spaces_after_comma'] || Preg::match('/\R/', $newContent))
                && !$this->isCommentLastLineToken($tokens, $index + 2)
            ) {
                $newContent = ltrim($newContent, " \t");
            }

            $tokens[$nextIndex] = new Token([\T_WHITESPACE, '' === $newContent ? ' ' : $newContent]);

            return;
        }

        if (!$this->isCommentLastLineToken($tokens, $index + 1)) {
            $tokens->insertAt($index + 1, new Token([\T_WHITESPACE, ' ']));
        }
    }

    /**
     * Check if last item of current line is a comment.
     *
     * @param Tokens $tokens tokens to handle
     * @param int    $index  index of token
     */
    private function isCommentLastLineToken(Tokens $tokens, int $index): bool
    {
        if (!$tokens[$index]->isComment() || !$tokens[$index + 1]->isWhitespace()) {
            return false;
        }

        $content = $tokens[$index + 1]->getContent();

        return $content !== ltrim($content, "\r\n");
    }

    /**
     * Checks if token is new line.
     */
    private function isNewline(Token $token): bool
    {
        return $token->isWhitespace() && str_contains($token->getContent(), "\n");
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	/*
6	* This file is part of PHP CS Fixer.
7	*
8	* (c) Fabien Potencier <fabien@symfony.com>
9	* Dariusz Rumiński <dariusz.ruminski@gmail.com>
10	*
11	* This source file is subject to the MIT license that is bundled
12	* with this source code in the file LICENSE.
13	*/
14
15	namespace PhpCsFixer\Fixer\FunctionNotation;
16
17	use PhpCsFixer\AbstractFixer;
18	use PhpCsFixer\Fixer\ConfigurableFixerInterface;
19	use PhpCsFixer\Fixer\ConfigurableFixerTrait;
20	use PhpCsFixer\Fixer\WhitespacesAwareFixerInterface;
21	use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
22	use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
23	use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
24	use PhpCsFixer\FixerDefinition\CodeSample;
25	use PhpCsFixer\FixerDefinition\FixerDefinition;
26	use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
27	use PhpCsFixer\Future;
28	use PhpCsFixer\Preg;
29	use PhpCsFixer\Tokenizer\CT;
30	use PhpCsFixer\Tokenizer\Token;
31	use PhpCsFixer\Tokenizer\Tokens;
32
33	/**
34	* @phpstan-type _AutogeneratedInputConfiguration array{
35	* after_heredoc?: bool,
36	* attribute_placement?: 'ignore'\|'same_line'\|'standalone',
37	* keep_multiple_spaces_after_comma?: bool,
38	* on_multiline?: 'ensure_fully_multiline'\|'ensure_single_line'\|'ignore',
39	* }
40	* @phpstan-type _AutogeneratedComputedConfiguration array{
41	* after_heredoc: bool,
42	* attribute_placement: 'ignore'\|'same_line'\|'standalone',
43	* keep_multiple_spaces_after_comma: bool,
44	* on_multiline: 'ensure_fully_multiline'\|'ensure_single_line'\|'ignore',
45	* }
46	*
47	* @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
48	*
49	* @author Kuanhung Chen <ericj.tw@gmail.com>
50	*
51	* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
52	*/
53	final class MethodArgumentSpaceFixer extends AbstractFixer implements ConfigurableFixerInterface, WhitespacesAwareFixerInterface
54	{
55	/** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
56	use ConfigurableFixerTrait;
57
58	public function getDefinition(): FixerDefinitionInterface
59	{
60	return new FixerDefinition(	3✔
61	'In method arguments and method call, there MUST NOT be a space before each comma and there MUST be one space after each comma. Argument lists MAY be split across multiple lines, where each subsequent line is indented once. When doing so, the first item in the list MUST be on the next line, and there MUST be only one argument per line.',	3✔
62	[	3✔
63	new CodeSample(	3✔
64	"<?php\nfunction sample(\$a=10,\$b=20,\$c=30) {}\nsample(1, 2);\n",	3✔
65	null	3✔
66	),	3✔
67	new CodeSample(	3✔
68	"<?php\nfunction sample(\$a=10,\$b=20,\$c=30) {}\nsample(1, 2);\n",	3✔
69	['keep_multiple_spaces_after_comma' => false]	3✔
70	),	3✔
71	new CodeSample(	3✔
72	"<?php\nfunction sample(\$a=10,\$b=20,\$c=30) {}\nsample(1, 2);\n",	3✔
73	['keep_multiple_spaces_after_comma' => true]	3✔
74	),	3✔
75	new CodeSample(	3✔
76	"<?php\nfunction sample(\$a=10,\n \$b=20,\$c=30) {}\nsample(1,\n 2);\n",	3✔
77	['on_multiline' => 'ensure_fully_multiline']	3✔
78	),	3✔
79	new CodeSample(	3✔
80	"<?php\nfunction sample(\n \$a=10,\n \$b=20,\n \$c=30\n) {}\nsample(\n 1,\n 2\n);\n",	3✔
81	['on_multiline' => 'ensure_single_line']	3✔
82	),	3✔
83	new CodeSample(	3✔
84	"<?php\nfunction sample(\$a=10,\n \$b=20,\$c=30) {}\nsample(1, \n 2);\nsample('foo', 'foobarbaz', 'baz');\nsample('foobar', 'bar', 'baz');\n",	3✔
85	[	3✔
86	'on_multiline' => 'ensure_fully_multiline',	3✔
87	'keep_multiple_spaces_after_comma' => true,	3✔
88	]	3✔
89	),	3✔
90	new CodeSample(	3✔
91	"<?php\nfunction sample(\$a=10,\n \$b=20,\$c=30) {}\nsample(1, \n 2);\nsample('foo', 'foobarbaz', 'baz');\nsample('foobar', 'bar', 'baz');\n",	3✔
92	[	3✔
93	'on_multiline' => 'ensure_fully_multiline',	3✔
94	'keep_multiple_spaces_after_comma' => false,	3✔
95	]	3✔
96	),	3✔
97	new CodeSample(	3✔
98	"<?php\nfunction sample(#[Foo] #[Bar] \$a=10,\n \$b=20,\$c=30) {}\nsample(1, 2);\n",	3✔
99	[	3✔
100	'on_multiline' => 'ensure_fully_multiline',	3✔
101	'attribute_placement' => 'ignore',	3✔
102	]	3✔
103	),	3✔
104	new CodeSample(	3✔
105	"<?php\nfunction sample(#[Foo]\n #[Bar]\n \$a=10,\n \$b=20,\$c=30) {}\nsample(1, 2);\n",	3✔
106	[	3✔
107	'on_multiline' => 'ensure_fully_multiline',	3✔
108	'attribute_placement' => 'same_line',	3✔
109	]	3✔
110	),	3✔
111	new CodeSample(	3✔
112	"<?php\nfunction sample(#[Foo] #[Bar] \$a=10,\n \$b=20,\$c=30) {}\nsample(1, 2);\n",	3✔
113	[	3✔
114	'on_multiline' => 'ensure_fully_multiline',	3✔
115	'attribute_placement' => 'standalone',	3✔
116	]	3✔
117	),	3✔
118	new CodeSample(	3✔
119	<<<'SAMPLE'	3✔
120	<?php
121	sample(
122	<<<EOD
123	foo
124	EOD
125	,
126	'bar'
127	);
128
129	SAMPLE,	3✔
130	['after_heredoc' => true]	3✔
131	),	3✔
132	],	3✔
133	'This fixer covers rules defined in PSR2 ¶4.4, ¶4.6.'	3✔
134	);	3✔
135	}
136
137	public function isCandidate(Tokens $tokens): bool
138	{
139	return $tokens->isTokenKindFound('(');	167✔
140	}
141
142	/**
143	* {@inheritdoc}
144	*
145	* Must run before ArrayIndentationFixer, StatementIndentationFixer.
146	* Must run after CombineNestedDirnameFixer, FunctionDeclarationFixer, ImplodeCallFixer, LambdaNotUsedImportFixer, NoMultilineWhitespaceAroundDoubleArrowFixer, NoUselessSprintfFixer, PowToExponentiationFixer, StrictParamFixer.
147	*/
148	public function getPriority(): int
149	{
150	return 30;	1✔
151	}
152
153	protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
154	{
155	$expectedTokens = [\T_LIST, \T_FUNCTION, CT::T_USE_LAMBDA, \T_FN, \T_CLASS];	165✔
156
157	$tokenCount = $tokens->count();	165✔
158	for ($index = 1; $index < $tokenCount; ++$index) {	165✔
159	$token = $tokens[$index];	165✔
160
161	if (!$token->equals('(')) {	165✔
162	continue;	165✔
163	}
164
165	$meaningfulTokenBeforeParenthesis = $tokens[$tokens->getPrevMeaningfulToken($index)];	165✔
166
167	if (
168	$meaningfulTokenBeforeParenthesis->isKeyword()	165✔
169	&& !$meaningfulTokenBeforeParenthesis->isGivenKind($expectedTokens)	165✔
170	) {
171	continue;	29✔
172	}
173
174	$isMultiline = $this->fixFunction($tokens, $index);	157✔
175
176	if (
177	$isMultiline	157✔
178	&& 'ensure_fully_multiline' === $this->configuration['on_multiline']	157✔
179	&& !$meaningfulTokenBeforeParenthesis->isGivenKind(\T_LIST)	157✔
180	) {
181	$this->ensureFunctionFullyMultiline($tokens, $index);	69✔
182	}
183	}
184	}
185
186	protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
187	{
188	return new FixerConfigurationResolver([	176✔
189	(new FixerOptionBuilder('keep_multiple_spaces_after_comma', 'Whether keep multiple spaces after comma.'))	176✔
190	->setAllowedTypes(['bool'])	176✔
191	->setDefault(false)	176✔
192	->getOption(),	176✔
193	(new FixerOptionBuilder(	176✔
194	'on_multiline',	176✔
195	'Defines how to handle function arguments lists that contain newlines.'	176✔
196	))	176✔
197	->setAllowedValues(['ignore', 'ensure_single_line', 'ensure_fully_multiline'])	176✔
198	->setDefault('ensure_fully_multiline')	176✔
199	->getOption(),	176✔
200	(new FixerOptionBuilder('after_heredoc', 'Whether the whitespace between heredoc end and comma should be removed.'))	176✔
201	->setAllowedTypes(['bool'])	176✔
202	->setDefault(Future::getV4OrV3(true, false))	176✔
203	->getOption(),	176✔
204	(new FixerOptionBuilder(	176✔
205	'attribute_placement',	176✔
206	'Defines how to handle argument attributes when function definition is multiline.'	176✔
207	))	176✔
208	->setAllowedValues(['ignore', 'same_line', 'standalone'])	176✔
209	->setDefault('standalone')	176✔
210	->getOption(),	176✔
211	]);	176✔
212	}
213
214	/**
215	* Fix arguments spacing for given function.
216	*
217	* @param Tokens $tokens Tokens to handle
218	* @param int $startFunctionIndex Start parenthesis position
219	*
220	* @return bool whether the function is multiline
221	*/
222	private function fixFunction(Tokens $tokens, int $startFunctionIndex): bool
223	{
224	$isMultiline = false;	157✔
225
226	$endFunctionIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startFunctionIndex);	157✔
227	$firstWhitespaceIndex = $this->findWhitespaceIndexAfterParenthesis($tokens, $startFunctionIndex, $endFunctionIndex);	157✔
228	$lastWhitespaceIndex = $this->findWhitespaceIndexAfterParenthesis($tokens, $endFunctionIndex, $startFunctionIndex);	157✔
229
230	foreach ([$firstWhitespaceIndex, $lastWhitespaceIndex] as $index) {	157✔
231	if (null === $index \|\| !Preg::match('/\R/', $tokens[$index]->getContent())) {	157✔
232	continue;	124✔
233	}
234
235	if ('ensure_single_line' !== $this->configuration['on_multiline']) {	87✔
236	$isMultiline = true;	73✔
237
238	continue;	73✔
239	}
240
241	$newLinesRemoved = $this->ensureSingleLine($tokens, $index);	15✔
242
243	if (!$newLinesRemoved) {	15✔
244	$isMultiline = true;	4✔
245	}
246	}
247
248	for ($index = $endFunctionIndex - 1; $index > $startFunctionIndex; --$index) {	157✔
249	$token = $tokens[$index];	155✔
250
251	if ($token->equals(')')) {	155✔
252	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);	32✔
253
254	continue;	32✔
255	}
256
257	if ($token->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_CLOSE)) {	155✔
258	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $index);	3✔
259
260	continue;	3✔
261	}
262
263	if ($token->equals('}')) {	155✔
264	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);	6✔
265
266	continue;	6✔
267	}
268
269	if ($token->equals(',')) {	155✔
270	$this->fixSpace($tokens, $index);	148✔
271	if (!$isMultiline && $this->isNewline($tokens[$index + 1])) {	148✔
272	$isMultiline = true;	22✔
273	}
274	}
275	}
276
277	return $isMultiline;	157✔
278	}
279
280	private function findWhitespaceIndexAfterParenthesis(Tokens $tokens, int $startParenthesisIndex, int $endParenthesisIndex): ?int
281	{
282	$direction = $endParenthesisIndex > $startParenthesisIndex ? 1 : -1;	157✔
283	$startIndex = $startParenthesisIndex + $direction;	157✔
284	$endIndex = $endParenthesisIndex - $direction;	157✔
285
286	for ($index = $startIndex; $index !== $endIndex; $index += $direction) {	157✔
287	$token = $tokens[$index];	157✔
288
289	if ($token->isWhitespace()) {	157✔
290	return $index;	90✔
291	}
292
293	if (!$token->isComment()) {	131✔
294	break;	123✔
295	}
296	}
297
298	return null;	123✔
299	}
300
301	/**
302	* @return bool Whether newlines were removed from the whitespace token
303	*/
304	private function ensureSingleLine(Tokens $tokens, int $index): bool
305	{
306	$previousToken = $tokens[$index - 1];	16✔
307
308	if ($previousToken->isComment() && !str_starts_with($previousToken->getContent(), '/*')) {	16✔
309	return false;	4✔
310	}
311
312	$content = Preg::replace('/\R\h*/', '', $tokens[$index]->getContent());	12✔
313
314	$tokens->ensureWhitespaceAtIndex($index, 0, $content);	12✔
315
316	return true;	12✔
317	}
318
319	private function ensureFunctionFullyMultiline(Tokens $tokens, int $startFunctionIndex): void
320	{
321	// find out what the indentation is
322	$searchIndex = $startFunctionIndex;	69✔
323	do {
324	$prevWhitespaceTokenIndex = $tokens->getPrevTokenOfKind(	69✔
325	$searchIndex,	69✔
326	[[\T_ENCAPSED_AND_WHITESPACE], [\T_INLINE_HTML], [\T_WHITESPACE]],	69✔
327	);	69✔
328
329	$searchIndex = $prevWhitespaceTokenIndex;	69✔
330	} while (null !== $prevWhitespaceTokenIndex	69✔
331	&& !str_contains($tokens[$prevWhitespaceTokenIndex]->getContent(), "\n")	69✔
332	);
333
334	if (null === $prevWhitespaceTokenIndex) {	69✔
335	$existingIndentation = '';	42✔
336	} elseif (!$tokens[$prevWhitespaceTokenIndex]->isGivenKind(\T_WHITESPACE)) {	34✔
337	return;	6✔
338	} else {
339	$existingIndentation = $tokens[$prevWhitespaceTokenIndex]->getContent();	28✔
340	$lastLineIndex = strrpos($existingIndentation, "\n");	28✔
341	$existingIndentation = false === $lastLineIndex	28✔
342	? $existingIndentation	×
343	: substr($existingIndentation, $lastLineIndex + 1);	28✔
344	}
345
346	$indentation = $existingIndentation.$this->whitespacesConfig->getIndent();	63✔
347	$endFunctionIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startFunctionIndex);	63✔
348
349	$wasWhitespaceBeforeEndFunctionAddedAsNewToken = $tokens->ensureWhitespaceAtIndex(	63✔
350	$tokens[$endFunctionIndex - 1]->isWhitespace() ? $endFunctionIndex - 1 : $endFunctionIndex,	63✔
351	0,	63✔
352	$this->whitespacesConfig->getLineEnding().$existingIndentation	63✔
353	);	63✔
354
355	if ($wasWhitespaceBeforeEndFunctionAddedAsNewToken) {	63✔
356	++$endFunctionIndex;	30✔
357	}
358
359	for ($index = $endFunctionIndex - 1; $index > $startFunctionIndex; --$index) {	63✔
360	$token = $tokens[$index];	63✔
361
362	// skip nested method calls and arrays
363	if ($token->equals(')')) {	63✔
364	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);	6✔
365
366	continue;	6✔
367	}
368
369	// skip nested arrays
370	if ($token->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_CLOSE)) {	63✔
371	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $index);	2✔
372
373	continue;	2✔
374	}
375
376	if ($token->equals('}')) {	63✔
377	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);	2✔
378
379	continue;	2✔
380	}
381
382	if ($tokens[$tokens->getNextMeaningfulToken($index)]->equals(')')) {	63✔
383	continue;	63✔
384	}
385
386	if ($token->isGivenKind(CT::T_ATTRIBUTE_CLOSE)) {	63✔
387	if ('standalone' === $this->configuration['attribute_placement']) {	8✔
388	$this->fixNewline($tokens, $index, $indentation);	6✔
389	} elseif ('same_line' === $this->configuration['attribute_placement']) {	3✔
390	$this->ensureSingleLine($tokens, $index + 1);	2✔
391	$tokens->ensureWhitespaceAtIndex($index + 1, 0, ' ');	2✔
392	}
393	$index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ATTRIBUTE, $index);	8✔
394
395	continue;	8✔
396	}
397
398	if ($token->equals(',')) {	63✔
399	$this->fixNewline($tokens, $index, $indentation);	58✔
400	}
401	}
402
403	$this->fixNewline($tokens, $startFunctionIndex, $indentation, false);	63✔
404	}
405
406	/**
407	* Method to insert newline after comma, attribute or opening parenthesis.
408	*
409	* @param int $index index of a comma
410	* @param string $indentation the indentation that should be used
411	* @param bool $override whether to override the existing character or not
412	*/
413	private function fixNewline(Tokens $tokens, int $index, string $indentation, bool $override = true): void
414	{
415	if ($tokens[$index + 1]->isComment()) {	63✔
416	return;	4✔
417	}
418
419	if ($tokens[$index + 2]->isComment()) {	61✔
420	$nextMeaningfulTokenIndex = $tokens->getNextMeaningfulToken($index + 2);	6✔
421	if (!$this->isNewline($tokens[$nextMeaningfulTokenIndex - 1])) {	6✔
422	if ($tokens[$nextMeaningfulTokenIndex - 1]->isWhitespace()) {	6✔
423	$tokens->clearAt($nextMeaningfulTokenIndex - 1);	2✔
424	}
425
426	$tokens->ensureWhitespaceAtIndex($nextMeaningfulTokenIndex, 0, $this->whitespacesConfig->getLineEnding().$indentation);	6✔
427	}
428
429	return;	6✔
430	}
431
432	$nextMeaningfulTokenIndex = $tokens->getNextMeaningfulToken($index);	59✔
433
434	if ($tokens[$nextMeaningfulTokenIndex]->equals(')')) {	59✔
435	return;	×
436	}
437
438	$tokens->ensureWhitespaceAtIndex($index + 1, 0, $this->whitespacesConfig->getLineEnding().$indentation);	59✔
439	}
440
441	/**
442	* Method to insert space after comma and remove space before comma.
443	*/
444	private function fixSpace(Tokens $tokens, int $index): void
445	{
446	// remove space before comma if exist
447	if ($tokens[$index - 1]->isWhitespace()) {	148✔
448	$prevIndex = $tokens->getPrevNonWhitespace($index - 1);	63✔
449
450	if (
451	!$tokens[$prevIndex]->equals(',') && !$tokens[$prevIndex]->isComment()	63✔
452	&& (true === $this->configuration['after_heredoc'] \|\| !$tokens[$prevIndex]->isGivenKind(\T_END_HEREDOC))	63✔
453	) {
454	$tokens->clearAt($index - 1);	47✔
455	}
456	}
457
458	$nextIndex = $index + 1;	148✔
459	$nextToken = $tokens[$nextIndex];	148✔
460
461	// Two cases for fix space after comma (exclude multiline comments)
462	// 1) multiple spaces after comma
463	// 2) no space after comma
464	if ($nextToken->isWhitespace()) {	148✔
465	$newContent = $nextToken->getContent();	142✔
466
467	if ('ensure_single_line' === $this->configuration['on_multiline']) {	142✔
468	$newContent = Preg::replace('/\R/', '', $newContent);	13✔
469	}
470
471	if (
472	(false === $this->configuration['keep_multiple_spaces_after_comma'] \|\| Preg::match('/\R/', $newContent))	142✔
473	&& !$this->isCommentLastLineToken($tokens, $index + 2)	142✔
474	) {
475	$newContent = ltrim($newContent, " \t");	122✔
476	}
477
478	$tokens[$nextIndex] = new Token([\T_WHITESPACE, '' === $newContent ? ' ' : $newContent]);	142✔
479
480	return;	142✔
481	}
482
483	if (!$this->isCommentLastLineToken($tokens, $index + 1)) {	51✔
484	$tokens->insertAt($index + 1, new Token([\T_WHITESPACE, ' ']));	45✔
485	}
486	}
487
488	/**
489	* Check if last item of current line is a comment.
490	*
491	* @param Tokens $tokens tokens to handle
492	* @param int $index index of token
493	*/
494	private function isCommentLastLineToken(Tokens $tokens, int $index): bool
495	{
496	if (!$tokens[$index]->isComment() \|\| !$tokens[$index + 1]->isWhitespace()) {	136✔
497	return false;	126✔
498	}
499
500	$content = $tokens[$index + 1]->getContent();	16✔
501
502	return $content !== ltrim($content, "\r\n");	16✔
503	}
504
505	/**
506	* Checks if token is new line.
507	*/
508	private function isNewline(Token $token): bool
509	{
510	return $token->isWhitespace() && str_contains($token->getContent(), "\n");	107✔
511	}
512	}

keradus / PHP-CS-Fixer / 18051010410

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

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