@averay/codeformat 0.2.1 → 0.2.3

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/FunctionNotation/DateTimeCreateFromFormatCallFixer.php

@@ -0,0 +1,164 @@
+<?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\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Analyzer\ArgumentsAnalyzer;
+use PhpCsFixer\Tokenizer\Analyzer\NamespaceUsesAnalyzer;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class DateTimeCreateFromFormatCallFixer extends AbstractFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'The first argument of `DateTime::createFromFormat` method must start with `!`.',
+            [
+                new CodeSample("<?php \\DateTime::createFromFormat('Y-m-d', '2022-02-11');\n"),
+            ],
+            "Consider this code:
+    `DateTime::createFromFormat('Y-m-d', '2022-02-11')`.
+    What value will be returned? '2022-02-11 00:00:00.0'?
+    No, actual return value has 'H:i:s' section like '2022-02-11 16:55:37.0'.
+    Change 'Y-m-d' to '!Y-m-d', return value will be '2022-02-11 00:00:00.0'.
+    So, adding `!` to format string will make return value more intuitive.",
+            'Risky when depending on the actual timings being used even when not explicit set in format.'
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after NoUselessConcatOperatorFixer.
+     */
+    public function getPriority(): int
+    {
+        return 0;
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isTokenKindFound(T_DOUBLE_COLON);
+    }
+
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $argumentsAnalyzer = new ArgumentsAnalyzer();
+        $namespaceUsesAnalyzer = new NamespaceUsesAnalyzer();
+
+        foreach ($tokens->getNamespaceDeclarations() as $namespace) {
+            $scopeStartIndex = $namespace->getScopeStartIndex();
+            $useDeclarations = $namespaceUsesAnalyzer->getDeclarationsInNamespace($tokens, $namespace);
+
+            for ($index = $namespace->getScopeEndIndex(); $index > $scopeStartIndex; --$index) {
+                if (!$tokens[$index]->isGivenKind(T_DOUBLE_COLON)) {
+                    continue;
+                }
+
+                $functionNameIndex = $tokens->getNextMeaningfulToken($index);
+
+                if (!$tokens[$functionNameIndex]->equals([T_STRING, 'createFromFormat'], false)) {
+                    continue;
+                }
+
+                if (!$tokens[$tokens->getNextMeaningfulToken($functionNameIndex)]->equals('(')) {
+                    continue;
+                }
+
+                $classNameIndex = $tokens->getPrevMeaningfulToken($index);
+
+                if (!$tokens[$classNameIndex]->equalsAny([[T_STRING, \DateTime::class], [T_STRING, \DateTimeImmutable::class]], false)) {
+                    continue;
+                }
+
+                $preClassNameIndex = $tokens->getPrevMeaningfulToken($classNameIndex);
+
+                if ($tokens[$preClassNameIndex]->isGivenKind(T_NS_SEPARATOR)) {
+                    if ($tokens[$tokens->getPrevMeaningfulToken($preClassNameIndex)]->isGivenKind(T_STRING)) {
+                        continue;
+                    }
+                } elseif (!$namespace->isGlobalNamespace()) {
+                    continue;
+                } else {
+                    foreach ($useDeclarations as $useDeclaration) {
+                        foreach (['datetime', 'datetimeimmutable'] as $name) {
+                            if ($name === strtolower($useDeclaration->getShortName()) && $name !== strtolower($useDeclaration->getFullName())) {
+                                continue 3;
+                            }
+                        }
+                    }
+                }
+
+                $openIndex = $tokens->getNextTokenOfKind($functionNameIndex, ['(']);
+                $closeIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $openIndex);
+
+                $argumentIndex = $this->getFirstArgumentTokenIndex($tokens, $argumentsAnalyzer->getArguments($tokens, $openIndex, $closeIndex));
+
+                if (null === $argumentIndex) {
+                    continue;
+                }
+
+                $format = $tokens[$argumentIndex]->getContent();
+
+                if (\strlen($format) < 3) {
+                    continue;
+                }
+
+                $offset = 'b' === $format[0] || 'B' === $format[0] ? 2 : 1;
+
+                if ('!' === $format[$offset]) {
+                    continue;
+                }
+
+                $tokens->clearAt($argumentIndex);
+                $tokens->insertAt($argumentIndex, new Token([T_CONSTANT_ENCAPSED_STRING, substr_replace($format, '!', $offset, 0)]));
+            }
+        }
+    }
+
+    /**
+     * @param array<int, int> $arguments
+     */
+    private function getFirstArgumentTokenIndex(Tokens $tokens, array $arguments): ?int
+    {
+        if (2 !== \count($arguments)) {
+            return null;
+        }
+
+        $argumentStartIndex = array_key_first($arguments);
+        $argumentEndIndex = $arguments[$argumentStartIndex];
+        $argumentStartIndex = $tokens->getNextMeaningfulToken($argumentStartIndex - 1);
+
+        if (
+            $argumentStartIndex !== $argumentEndIndex
+            && $tokens->getNextMeaningfulToken($argumentStartIndex) <= $argumentEndIndex
+        ) {
+            return null; // argument is not a simple single string
+        }
+
+        return !$tokens[$argumentStartIndex]->isGivenKind(T_CONSTANT_ENCAPSED_STRING)
+            ? null // first argument is not a string
+            : $argumentStartIndex;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/FunctionNotation/FopenFlagOrderFixer.php

@@ -0,0 +1,123 @@
+<?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\AbstractFopenFlagFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class FopenFlagOrderFixer extends AbstractFopenFlagFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Order the flags in `fopen` calls, `b` and `t` must be last.',
+            [new CodeSample("<?php\n\$a = fopen(\$foo, 'br+');\n")],
+            null,
+            'Risky when the function `fopen` is overridden.'
+        );
+    }
+
+    protected function fixFopenFlagToken(Tokens $tokens, int $argumentStartIndex, int $argumentEndIndex): void
+    {
+        $argumentFlagIndex = null;
+
+        for ($i = $argumentStartIndex; $i <= $argumentEndIndex; ++$i) {
+            if ($tokens[$i]->isGivenKind([T_WHITESPACE, T_COMMENT, T_DOC_COMMENT])) {
+                continue;
+            }
+
+            if (null !== $argumentFlagIndex) {
+                return; // multiple meaningful tokens found, no candidate for fixing
+            }
+
+            $argumentFlagIndex = $i;
+        }
+
+        // check if second argument is candidate
+        if (null === $argumentFlagIndex || !$tokens[$argumentFlagIndex]->isGivenKind(T_CONSTANT_ENCAPSED_STRING)) {
+            return;
+        }
+
+        $content = $tokens[$argumentFlagIndex]->getContent();
+        $contentQuote = $content[0]; // `'`, `"`, `b` or `B`
+
+        if ('b' === $contentQuote || 'B' === $contentQuote) {
+            $binPrefix = $contentQuote;
+            $contentQuote = $content[1]; // `'` or `"`
+            $mode = substr($content, 2, -1);
+        } else {
+            $binPrefix = '';
+            $mode = substr($content, 1, -1);
+        }
+
+        $modeLength = \strlen($mode);
+        if ($modeLength < 2) {
+            return; // nothing to sort
+        }
+
+        if (false === $this->isValidModeString($mode)) {
+            return;
+        }
+
+        $split = $this->sortFlags(Preg::split('#([^\+]\+?)#', $mode, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE));
+        $newContent = $binPrefix.$contentQuote.implode('', $split).$contentQuote;
+
+        if ($content !== $newContent) {
+            $tokens[$argumentFlagIndex] = new Token([T_CONSTANT_ENCAPSED_STRING, $newContent]);
+        }
+    }
+
+    /**
+     * @param list<string> $flags
+     *
+     * @return list<string>
+     */
+    private function sortFlags(array $flags): array
+    {
+        usort(
+            $flags,
+            static function (string $flag1, string $flag2): int {
+                if ($flag1 === $flag2) {
+                    return 0;
+                }
+
+                if ('b' === $flag1) {
+                    return 1;
+                }
+
+                if ('b' === $flag2) {
+                    return -1;
+                }
+
+                if ('t' === $flag1) {
+                    return 1;
+                }
+
+                if ('t' === $flag2) {
+                    return -1;
+                }
+
+                return $flag1 < $flag2 ? -1 : 1;
+            }
+        );
+
+        return $flags;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/FunctionNotation/FopenFlagsFixer.php

@@ -0,0 +1,120 @@
+<?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\AbstractFopenFlagFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+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\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  b_mode?: bool,
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  b_mode: bool,
+ * }
+ */
+final class FopenFlagsFixer extends AbstractFopenFlagFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'The flags in `fopen` calls must omit `t`, and `b` must be omitted or included consistently.',
+            [
+                new CodeSample("<?php\n\$a = fopen(\$foo, 'rwt');\n"),
+                new CodeSample("<?php\n\$a = fopen(\$foo, 'rwt');\n", ['b_mode' => false]),
+            ],
+            null,
+            'Risky when the function `fopen` is overridden.'
+        );
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('b_mode', 'The `b` flag must be used (`true`) or omitted (`false`).'))
+                ->setAllowedTypes(['bool'])
+                ->setDefault(true)
+                ->getOption(),
+        ]);
+    }
+
+    protected function fixFopenFlagToken(Tokens $tokens, int $argumentStartIndex, int $argumentEndIndex): void
+    {
+        $argumentFlagIndex = null;
+
+        for ($i = $argumentStartIndex; $i <= $argumentEndIndex; ++$i) {
+            if ($tokens[$i]->isGivenKind([T_WHITESPACE, T_COMMENT, T_DOC_COMMENT])) {
+                continue;
+            }
+
+            if (null !== $argumentFlagIndex) {
+                return; // multiple meaningful tokens found, no candidate for fixing
+            }
+
+            $argumentFlagIndex = $i;
+        }
+
+        // check if second argument is candidate
+        if (null === $argumentFlagIndex || !$tokens[$argumentFlagIndex]->isGivenKind(T_CONSTANT_ENCAPSED_STRING)) {
+            return;
+        }
+
+        $content = $tokens[$argumentFlagIndex]->getContent();
+        $contentQuote = $content[0]; // `'`, `"`, `b` or `B`
+
+        if ('b' === $contentQuote || 'B' === $contentQuote) {
+            $binPrefix = $contentQuote;
+            $contentQuote = $content[1]; // `'` or `"`
+            $mode = substr($content, 2, -1);
+        } else {
+            $binPrefix = '';
+            $mode = substr($content, 1, -1);
+        }
+
+        if (false === $this->isValidModeString($mode)) {
+            return;
+        }
+
+        $mode = str_replace('t', '', $mode);
+
+        if (true === $this->configuration['b_mode']) {
+            if (!str_contains($mode, 'b')) {
+                $mode .= 'b';
+            }
+        } else {
+            $mode = str_replace('b', '', $mode);
+        }
+
+        $newContent = $binPrefix.$contentQuote.$mode.$contentQuote;
+
+        if ($content !== $newContent) {
+            $tokens[$argumentFlagIndex] = new Token([T_CONSTANT_ENCAPSED_STRING, $newContent]);
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/FunctionNotation/FunctionDeclarationFixer.php

@@ -0,0 +1,263 @@
+<?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\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Tokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+/**
+ * Fixer for rules defined in PSR2 generally (¶1 and ¶6).
+ *
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  closure_fn_spacing?: 'none'|'one',
+ *  closure_function_spacing?: 'none'|'one',
+ *  trailing_comma_single_line?: bool,
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  closure_fn_spacing: 'none'|'one',
+ *  closure_function_spacing: 'none'|'one',
+ *  trailing_comma_single_line: bool,
+ * }
+ */
+final class FunctionDeclarationFixer extends AbstractFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    /**
+     * @internal
+     */
+    public const SPACING_NONE = 'none';
+
+    /**
+     * @internal
+     */
+    public const SPACING_ONE = 'one';
+
+    private const SUPPORTED_SPACINGS = [self::SPACING_NONE, self::SPACING_ONE];
+
+    private string $singleLineWhitespaceOptions = " \t";
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isAnyTokenKindsFound([T_FUNCTION, T_FN]);
+    }
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Spaces should be properly placed in a function declaration.',
+            [
+                new CodeSample(
+                    '<?php
+
+class Foo
+{
+    public static function  bar   ( $baz , $foo )
+    {
+        return false;
+    }
+}
+
+function  foo  ($bar, $baz)
+{
+    return false;
+}
+'
+                ),
+                new CodeSample(
+                    '<?php
+$f = function () {};
+',
+                    ['closure_function_spacing' => self::SPACING_NONE]
+                ),
+                new CodeSample(
+                    '<?php
+$f = fn () => null;
+',
+                    ['closure_fn_spacing' => self::SPACING_NONE]
+                ),
+            ]
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before MethodArgumentSpaceFixer.
+     * Must run after SingleSpaceAfterConstructFixer, SingleSpaceAroundConstructFixer, UseArrowFunctionsFixer.
+     */
+    public function getPriority(): int
+    {
+        return 31;
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $tokensAnalyzer = new TokensAnalyzer($tokens);
+
+        for ($index = $tokens->count() - 1; $index >= 0; --$index) {
+            $token = $tokens[$index];
+
+            if (!$token->isGivenKind([T_FUNCTION, T_FN])) {
+                continue;
+            }
+
+            $startParenthesisIndex = $tokens->getNextTokenOfKind($index, ['(', ';', [T_CLOSE_TAG]]);
+
+            if (!$tokens[$startParenthesisIndex]->equals('(')) {
+                continue;
+            }
+
+            $endParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startParenthesisIndex);
+
+            if (false === $this->configuration['trailing_comma_single_line']
+                && !$tokens->isPartialCodeMultiline($index, $endParenthesisIndex)
+            ) {
+                $commaIndex = $tokens->getPrevMeaningfulToken($endParenthesisIndex);
+
+                if ($tokens[$commaIndex]->equals(',')) {
+                    $tokens->clearTokenAndMergeSurroundingWhitespace($commaIndex);
+                }
+            }
+
+            $startBraceIndex = $tokens->getNextTokenOfKind($endParenthesisIndex, [';', '{', [T_DOUBLE_ARROW]]);
+
+            // fix single-line whitespace before { or =>
+            // eg: `function foo(){}` => `function foo() {}`
+            // eg: `function foo()   {}` => `function foo() {}`
+            // eg: `fn()   =>` => `fn() =>`
+            if (
+                $tokens[$startBraceIndex]->equalsAny(['{', [T_DOUBLE_ARROW]])
+                && (
+                    !$tokens[$startBraceIndex - 1]->isWhitespace()
+                    || $tokens[$startBraceIndex - 1]->isWhitespace($this->singleLineWhitespaceOptions)
+                )
+            ) {
+                $tokens->ensureWhitespaceAtIndex($startBraceIndex - 1, 1, ' ');
+            }
+
+            $afterParenthesisIndex = $tokens->getNextNonWhitespace($endParenthesisIndex);
+            $afterParenthesisToken = $tokens[$afterParenthesisIndex];
+
+            if ($afterParenthesisToken->isGivenKind(CT::T_USE_LAMBDA)) {
+                // fix whitespace after CT:T_USE_LAMBDA (we might add a token, so do this before determining start and end parenthesis)
+                $tokens->ensureWhitespaceAtIndex($afterParenthesisIndex + 1, 0, ' ');
+
+                $useStartParenthesisIndex = $tokens->getNextTokenOfKind($afterParenthesisIndex, ['(']);
+                $useEndParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $useStartParenthesisIndex);
+
+                if (false === $this->configuration['trailing_comma_single_line']
+                    && !$tokens->isPartialCodeMultiline($index, $useEndParenthesisIndex)
+                ) {
+                    $commaIndex = $tokens->getPrevMeaningfulToken($useEndParenthesisIndex);
+
+                    if ($tokens[$commaIndex]->equals(',')) {
+                        $tokens->clearTokenAndMergeSurroundingWhitespace($commaIndex);
+                    }
+                }
+
+                // remove single-line edge whitespaces inside use parentheses
+                $this->fixParenthesisInnerEdge($tokens, $useStartParenthesisIndex, $useEndParenthesisIndex);
+
+                // fix whitespace before CT::T_USE_LAMBDA
+                $tokens->ensureWhitespaceAtIndex($afterParenthesisIndex - 1, 1, ' ');
+            }
+
+            // remove single-line edge whitespaces inside parameters list parentheses
+            $this->fixParenthesisInnerEdge($tokens, $startParenthesisIndex, $endParenthesisIndex);
+            $isLambda = $tokensAnalyzer->isLambda($index);
+
+            // remove whitespace before (
+            // eg: `function foo () {}` => `function foo() {}`
+            if (!$isLambda && $tokens[$startParenthesisIndex - 1]->isWhitespace() && !$tokens[$tokens->getPrevNonWhitespace($startParenthesisIndex - 1)]->isComment()) {
+                $tokens->clearAt($startParenthesisIndex - 1);
+            }
+
+            $option = $token->isGivenKind(T_FN) ? 'closure_fn_spacing' : 'closure_function_spacing';
+
+            if ($isLambda && self::SPACING_NONE === $this->configuration[$option]) {
+                // optionally remove whitespace after T_FUNCTION of a closure
+                // eg: `function () {}` => `function() {}`
+                if ($tokens[$index + 1]->isWhitespace()) {
+                    $tokens->clearAt($index + 1);
+                }
+            } else {
+                // otherwise, enforce whitespace after T_FUNCTION
+                // eg: `function     foo() {}` => `function foo() {}`
+                $tokens->ensureWhitespaceAtIndex($index + 1, 0, ' ');
+            }
+
+            if ($isLambda) {
+                $prev = $tokens->getPrevMeaningfulToken($index);
+
+                if ($tokens[$prev]->isGivenKind(T_STATIC)) {
+                    // fix whitespace after T_STATIC
+                    // eg: `$a = static     function(){};` => `$a = static function(){};`
+                    $tokens->ensureWhitespaceAtIndex($prev + 1, 0, ' ');
+                }
+            }
+        }
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('closure_function_spacing', 'Spacing to use before open parenthesis for closures.'))
+                ->setDefault(self::SPACING_ONE)
+                ->setAllowedValues(self::SUPPORTED_SPACINGS)
+                ->getOption(),
+            (new FixerOptionBuilder('closure_fn_spacing', 'Spacing to use before open parenthesis for short arrow functions.'))
+                ->setDefault(self::SPACING_ONE) // @TODO change to SPACING_NONE on next major 4.0
+                ->setAllowedValues(self::SUPPORTED_SPACINGS)
+                ->getOption(),
+            (new FixerOptionBuilder('trailing_comma_single_line', 'Whether trailing commas are allowed in single line signatures.'))
+                ->setAllowedTypes(['bool'])
+                ->setDefault(false)
+                ->getOption(),
+        ]);
+    }
+
+    private function fixParenthesisInnerEdge(Tokens $tokens, int $start, int $end): void
+    {
+        do {
+            --$end;
+        } while ($tokens->isEmptyAt($end));
+
+        // remove single-line whitespace before `)`
+        if ($tokens[$end]->isWhitespace($this->singleLineWhitespaceOptions)) {
+            $tokens->clearAt($end);
+        }
+
+        // remove single-line whitespace after `(`
+        if ($tokens[$start + 1]->isWhitespace($this->singleLineWhitespaceOptions)) {
+            $tokens->clearAt($start + 1);
+        }
+    }
+}