@averay/codeformat 0.2.7 → 0.2.9

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Operator/BinaryOperatorSpacesFixer.php

@@ -1,961 +0,0 @@
-<?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\Operator;
-
-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\Preg;
-use PhpCsFixer\Tokenizer\CT;
-use PhpCsFixer\Tokenizer\Token;
-use PhpCsFixer\Tokenizer\Tokens;
-use PhpCsFixer\Tokenizer\TokensAnalyzer;
-use PhpCsFixer\Utils;
-use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
-
-/**
- * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
- *
- * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
- *
- * @phpstan-type _AutogeneratedInputConfiguration array{
- *  default?: 'align'|'align_by_scope'|'align_single_space'|'align_single_space_by_scope'|'align_single_space_minimal'|'align_single_space_minimal_by_scope'|'at_least_single_space'|'no_space'|'single_space'|null,
- *  operators?: array<string, ?string>,
- * }
- * @phpstan-type _AutogeneratedComputedConfiguration array{
- *  default: 'align'|'align_by_scope'|'align_single_space'|'align_single_space_by_scope'|'align_single_space_minimal'|'align_single_space_minimal_by_scope'|'at_least_single_space'|'no_space'|'single_space'|null,
- *  operators: array<string, ?string>,
- * }
- */
-final class BinaryOperatorSpacesFixer extends AbstractFixer implements ConfigurableFixerInterface
-{
-    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
-    use ConfigurableFixerTrait;
-
-    /**
-     * @internal
-     */
-    public const SINGLE_SPACE = 'single_space';
-
-    /**
-     * @internal
-     */
-    public const AT_LEAST_SINGLE_SPACE = 'at_least_single_space';
-
-    /**
-     * @internal
-     */
-    public const NO_SPACE = 'no_space';
-
-    /**
-     * @internal
-     */
-    public const ALIGN = 'align';
-
-    /**
-     * @internal
-     */
-    public const ALIGN_BY_SCOPE = 'align_by_scope';
-
-    /**
-     * @internal
-     */
-    public const ALIGN_SINGLE_SPACE = 'align_single_space';
-
-    /**
-     * @internal
-     */
-    public const ALIGN_SINGLE_SPACE_BY_SCOPE = 'align_single_space_by_scope';
-
-    /**
-     * @internal
-     */
-    public const ALIGN_SINGLE_SPACE_MINIMAL = 'align_single_space_minimal';
-
-    /**
-     * @internal
-     */
-    public const ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE = 'align_single_space_minimal_by_scope';
-
-    /**
-     * @internal
-     *
-     * @const Placeholder used as anchor for right alignment.
-     */
-    public const ALIGN_PLACEHOLDER = "\x2 ALIGNABLE%d \x3";
-
-    /**
-     * @var list<string>
-     */
-    private const SUPPORTED_OPERATORS = [
-        '=',
-        '*',
-        '/',
-        '%',
-        '<',
-        '>',
-        '|',
-        '^',
-        '+',
-        '-',
-        '&',
-        '&=',
-        '&&',
-        '||',
-        '.=',
-        '/=',
-        '=>',
-        '==',
-        '>=',
-        '===',
-        '!=',
-        '<>',
-        '!==',
-        '<=',
-        'and',
-        'or',
-        'xor',
-        '-=',
-        '%=',
-        '*=',
-        '|=',
-        '+=',
-        '<<',
-        '<<=',
-        '>>',
-        '>>=',
-        '^=',
-        '**',
-        '**=',
-        '<=>',
-        '??',
-        '??=',
-    ];
-
-    /**
-     * @var list<null|string>
-     */
-    private const ALLOWED_VALUES = [
-        self::ALIGN,
-        self::ALIGN_BY_SCOPE,
-        self::ALIGN_SINGLE_SPACE,
-        self::ALIGN_SINGLE_SPACE_MINIMAL,
-        self::ALIGN_SINGLE_SPACE_BY_SCOPE,
-        self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE,
-        self::SINGLE_SPACE,
-        self::NO_SPACE,
-        self::AT_LEAST_SINGLE_SPACE,
-        null,
-    ];
-
-    /**
-     * Keep track of the deepest level ever achieved while
-     * parsing the code. Used later to replace alignment
-     * placeholders with spaces.
-     */
-    private int $deepestLevel;
-
-    /**
-     * Level counter of the current nest level.
-     * So one level alignments are not mixed with
-     * other level ones.
-     */
-    private int $currentLevel;
-
-    private TokensAnalyzer $tokensAnalyzer;
-
-    /**
-     * @var array<string, string>
-     */
-    private array $alignOperatorTokens = [];
-
-    /**
-     * @var array<string, string>
-     */
-    private array $operators = [];
-
-    public function getDefinition(): FixerDefinitionInterface
-    {
-        return new FixerDefinition(
-            'Binary operators should be surrounded by space as configured.',
-            [
-                new CodeSample(
-                    "<?php\n\$a= 1  + \$b^ \$d !==  \$e or   \$f;\n"
-                ),
-                new CodeSample(
-                    '<?php
-$aa=  1;
-$b=2;
-
-$c = $d    xor    $e;
-$f    -=  1;
-',
-                    ['operators' => ['=' => self::ALIGN, 'xor' => null]]
-                ),
-                new CodeSample(
-                    '<?php
-$a = $b +=$c;
-$d = $ee+=$f;
-
-$g = $b     +=$c;
-$h = $ee+=$f;
-',
-                    ['operators' => ['+=' => self::ALIGN_SINGLE_SPACE]]
-                ),
-                new CodeSample(
-                    '<?php
-$a = $b===$c;
-$d = $f   ===  $g;
-$h = $i===  $j;
-',
-                    ['operators' => ['===' => self::ALIGN_SINGLE_SPACE_MINIMAL]]
-                ),
-                new CodeSample(
-                    '<?php
-$foo = \json_encode($bar, JSON_PRESERVE_ZERO_FRACTION | JSON_PRETTY_PRINT);
-',
-                    ['operators' => ['|' => self::NO_SPACE]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo"            =>   1,
-    "baaaaaaaaaaar"  =>  11,
-];
-',
-                    ['operators' => ['=>' => self::SINGLE_SPACE]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo" => 12,
-    "baaaaaaaaaaar"  => 13,
-
-    "baz" => 1,
-];
-',
-                    ['operators' => ['=>' => self::ALIGN]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo" => 12,
-    "baaaaaaaaaaar"  => 13,
-
-    "baz" => 1,
-];
-',
-                    ['operators' => ['=>' => self::ALIGN_BY_SCOPE]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo" => 12,
-    "baaaaaaaaaaar"  => 13,
-
-    "baz" => 1,
-];
-',
-                    ['operators' => ['=>' => self::ALIGN_SINGLE_SPACE]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo" => 12,
-    "baaaaaaaaaaar"  => 13,
-
-    "baz" => 1,
-];
-',
-                    ['operators' => ['=>' => self::ALIGN_SINGLE_SPACE_BY_SCOPE]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo" => 12,
-    "baaaaaaaaaaar"  => 13,
-
-    "baz" => 1,
-];
-',
-                    ['operators' => ['=>' => self::ALIGN_SINGLE_SPACE_MINIMAL]]
-                ),
-                new CodeSample(
-                    '<?php
-$array = [
-    "foo" => 12,
-    "baaaaaaaaaaar"  => 13,
-
-    "baz" => 1,
-];
-',
-                    ['operators' => ['=>' => self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE]]
-                ),
-            ]
-        );
-    }
-
-    /**
-     * {@inheritdoc}
-     *
-     * Must run after ArrayIndentationFixer, ArraySyntaxFixer, AssignNullCoalescingToCoalesceEqualFixer, ListSyntaxFixer, LongToShorthandOperatorFixer, ModernizeStrposFixer, NoMultilineWhitespaceAroundDoubleArrowFixer, NoUnsetCastFixer, PowToExponentiationFixer, StandardizeNotEqualsFixer, StrictComparisonFixer.
-     */
-    public function getPriority(): int
-    {
-        return -32;
-    }
-
-    public function isCandidate(Tokens $tokens): bool
-    {
-        return true;
-    }
-
-    protected function configurePostNormalisation(): void
-    {
-        $this->operators = $this->resolveOperatorsFromConfig();
-    }
-
-    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
-    {
-        $this->tokensAnalyzer = new TokensAnalyzer($tokens);
-
-        // last and first tokens cannot be an operator
-        for ($index = $tokens->count() - 2; $index > 0; --$index) {
-            if (!$this->tokensAnalyzer->isBinaryOperator($index)) {
-                continue;
-            }
-
-            if ('=' === $tokens[$index]->getContent()) {
-                $isDeclare = $this->isEqualPartOfDeclareStatement($tokens, $index);
-                if (false === $isDeclare) {
-                    $this->fixWhiteSpaceAroundOperator($tokens, $index);
-                } else {
-                    $index = $isDeclare; // skip `declare(foo ==bar)`, see `declare_equal_normalize`
-                }
-            } else {
-                $this->fixWhiteSpaceAroundOperator($tokens, $index);
-            }
-
-            // previous of binary operator is now never an operator / previous of declare statement cannot be an operator
-            --$index;
-        }
-
-        if (\count($this->alignOperatorTokens) > 0) {
-            $this->fixAlignment($tokens, $this->alignOperatorTokens);
-        }
-    }
-
-    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
-    {
-        return new FixerConfigurationResolver([
-            (new FixerOptionBuilder('default', 'Default fix strategy.'))
-                ->setDefault(self::SINGLE_SPACE)
-                ->setAllowedValues(self::ALLOWED_VALUES)
-                ->getOption(),
-            (new FixerOptionBuilder('operators', 'Dictionary of `binary operator` => `fix strategy` values that differ from the default strategy. Supported are: '.Utils::naturalLanguageJoinWithBackticks(self::SUPPORTED_OPERATORS).'.'))
-                ->setAllowedTypes(['array<string, ?string>'])
-                ->setAllowedValues([static function (array $option): bool {
-                    foreach ($option as $operator => $value) {
-                        if (!\in_array($operator, self::SUPPORTED_OPERATORS, true)) {
-                            throw new InvalidOptionsException(
-                                \sprintf(
-                                    'Unexpected "operators" key, expected any of %s, got "%s".',
-                                    Utils::naturalLanguageJoin(self::SUPPORTED_OPERATORS),
-                                    \gettype($operator).'#'.$operator
-                                )
-                            );
-                        }
-
-                        if (!\in_array($value, self::ALLOWED_VALUES, true)) {
-                            throw new InvalidOptionsException(
-                                \sprintf(
-                                    'Unexpected value for operator "%s", expected any of %s, got "%s".',
-                                    $operator,
-                                    Utils::naturalLanguageJoin(array_map(
-                                        static fn ($value): string => Utils::toString($value),
-                                        self::ALLOWED_VALUES
-                                    )),
-                                    \is_object($value) ? \get_class($value) : (null === $value ? 'null' : \gettype($value).'#'.$value)
-                                )
-                            );
-                        }
-                    }
-
-                    return true;
-                }])
-                ->setDefault([])
-                ->getOption(),
-        ]);
-    }
-
-    private function fixWhiteSpaceAroundOperator(Tokens $tokens, int $index): void
-    {
-        $tokenContent = strtolower($tokens[$index]->getContent());
-
-        if (!\array_key_exists($tokenContent, $this->operators)) {
-            return; // not configured to be changed
-        }
-
-        if (self::SINGLE_SPACE === $this->operators[$tokenContent]) {
-            $this->fixWhiteSpaceAroundOperatorToSingleSpace($tokens, $index);
-
-            return;
-        }
-
-        if (self::AT_LEAST_SINGLE_SPACE === $this->operators[$tokenContent]) {
-            $this->fixWhiteSpaceAroundOperatorToAtLeastSingleSpace($tokens, $index);
-
-            return;
-        }
-
-        if (self::NO_SPACE === $this->operators[$tokenContent]) {
-            $this->fixWhiteSpaceAroundOperatorToNoSpace($tokens, $index);
-
-            return;
-        }
-
-        // schedule for alignment
-        $this->alignOperatorTokens[$tokenContent] = $this->operators[$tokenContent];
-
-        if (
-            self::ALIGN === $this->operators[$tokenContent]
-            || self::ALIGN_BY_SCOPE === $this->operators[$tokenContent]
-        ) {
-            return;
-        }
-
-        // fix white space after operator
-        if ($tokens[$index + 1]->isWhitespace()) {
-            if (
-                self::ALIGN_SINGLE_SPACE_MINIMAL === $this->operators[$tokenContent]
-                || self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE === $this->operators[$tokenContent]
-            ) {
-                $tokens[$index + 1] = new Token([T_WHITESPACE, ' ']);
-            }
-
-            return;
-        }
-
-        $tokens->insertAt($index + 1, new Token([T_WHITESPACE, ' ']));
-    }
-
-    private function fixWhiteSpaceAroundOperatorToSingleSpace(Tokens $tokens, int $index): void
-    {
-        // fix white space after operator
-        if ($tokens[$index + 1]->isWhitespace()) {
-            $content = $tokens[$index + 1]->getContent();
-            if (' ' !== $content && !str_contains($content, "\n") && !$tokens[$tokens->getNextNonWhitespace($index + 1)]->isComment()) {
-                $tokens[$index + 1] = new Token([T_WHITESPACE, ' ']);
-            }
-        } else {
-            $tokens->insertAt($index + 1, new Token([T_WHITESPACE, ' ']));
-        }
-
-        // fix white space before operator
-        if ($tokens[$index - 1]->isWhitespace()) {
-            $content = $tokens[$index - 1]->getContent();
-            if (' ' !== $content && !str_contains($content, "\n") && !$tokens[$tokens->getPrevNonWhitespace($index - 1)]->isComment()) {
-                $tokens[$index - 1] = new Token([T_WHITESPACE, ' ']);
-            }
-        } else {
-            $tokens->insertAt($index, new Token([T_WHITESPACE, ' ']));
-        }
-    }
-
-    private function fixWhiteSpaceAroundOperatorToAtLeastSingleSpace(Tokens $tokens, int $index): void
-    {
-        // fix white space after operator
-        if (!$tokens[$index + 1]->isWhitespace()) {
-            $tokens->insertAt($index + 1, new Token([T_WHITESPACE, ' ']));
-        }
-
-        // fix white space before operator
-        if (!$tokens[$index - 1]->isWhitespace()) {
-            $tokens->insertAt($index, new Token([T_WHITESPACE, ' ']));
-        }
-    }
-
-    private function fixWhiteSpaceAroundOperatorToNoSpace(Tokens $tokens, int $index): void
-    {
-        // fix white space after operator
-        if ($tokens[$index + 1]->isWhitespace()) {
-            $content = $tokens[$index + 1]->getContent();
-            if (!str_contains($content, "\n") && !$tokens[$tokens->getNextNonWhitespace($index + 1)]->isComment()) {
-                $tokens->clearAt($index + 1);
-            }
-        }
-
-        // fix white space before operator
-        if ($tokens[$index - 1]->isWhitespace()) {
-            $content = $tokens[$index - 1]->getContent();
-            if (!str_contains($content, "\n") && !$tokens[$tokens->getPrevNonWhitespace($index - 1)]->isComment()) {
-                $tokens->clearAt($index - 1);
-            }
-        }
-    }
-
-    /**
-     * @return false|int index of T_DECLARE where the `=` belongs to or `false`
-     */
-    private function isEqualPartOfDeclareStatement(Tokens $tokens, int $index)
-    {
-        $prevMeaningfulIndex = $tokens->getPrevMeaningfulToken($index);
-        if ($tokens[$prevMeaningfulIndex]->isGivenKind(T_STRING)) {
-            $prevMeaningfulIndex = $tokens->getPrevMeaningfulToken($prevMeaningfulIndex);
-            if ($tokens[$prevMeaningfulIndex]->equals('(')) {
-                $prevMeaningfulIndex = $tokens->getPrevMeaningfulToken($prevMeaningfulIndex);
-                if ($tokens[$prevMeaningfulIndex]->isGivenKind(T_DECLARE)) {
-                    return $prevMeaningfulIndex;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * @return array<string, string>
-     */
-    private function resolveOperatorsFromConfig(): array
-    {
-        $operators = [];
-
-        if (null !== $this->configuration['default']) {
-            foreach (self::SUPPORTED_OPERATORS as $operator) {
-                $operators[$operator] = $this->configuration['default'];
-            }
-        }
-
-        foreach ($this->configuration['operators'] as $operator => $value) {
-            if (null === $value) {
-                unset($operators[$operator]);
-            } else {
-                $operators[$operator] = $value;
-            }
-        }
-
-        return $operators;
-    }
-
-    // Alignment logic related methods
-
-    /**
-     * @param array<string, string> $toAlign
-     */
-    private function fixAlignment(Tokens $tokens, array $toAlign): void
-    {
-        $this->deepestLevel = 0;
-        $this->currentLevel = 0;
-
-        foreach ($toAlign as $tokenContent => $alignStrategy) {
-            // This fixer works partially on Tokens and partially on string representation of code.
-            // During the process of fixing internal state of single Token may be affected by injecting ALIGN_PLACEHOLDER to its content.
-            // The placeholder will be resolved by `replacePlaceholders` method by removing placeholder or changing it into spaces.
-            // That way of fixing the code causes disturbances in marking Token as changed - if code is perfectly valid then placeholder
-            // still be injected and removed, which will cause the `changed` flag to be set.
-            // To handle that unwanted behavior we work on clone of Tokens collection and then override original collection with fixed collection.
-            $tokensClone = clone $tokens;
-
-            if ('=>' === $tokenContent) {
-                $this->injectAlignmentPlaceholdersForArrow($tokensClone, 0, \count($tokens));
-            } else {
-                $this->injectAlignmentPlaceholdersDefault($tokensClone, 0, \count($tokens), $tokenContent);
-            }
-
-            // for all tokens that should be aligned but do not have anything to align with, fix spacing if needed
-            if (
-                self::ALIGN_SINGLE_SPACE === $alignStrategy
-                || self::ALIGN_SINGLE_SPACE_MINIMAL === $alignStrategy
-                || self::ALIGN_SINGLE_SPACE_BY_SCOPE === $alignStrategy
-                || self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE === $alignStrategy
-            ) {
-                if ('=>' === $tokenContent) {
-                    for ($index = $tokens->count() - 2; $index > 0; --$index) {
-                        if ($tokens[$index]->isGivenKind(T_DOUBLE_ARROW)) { // always binary operator, never part of declare statement
-                            $this->fixWhiteSpaceBeforeOperator($tokensClone, $index, $alignStrategy);
-                        }
-                    }
-                } elseif ('=' === $tokenContent) {
-                    for ($index = $tokens->count() - 2; $index > 0; --$index) {
-                        if ('=' === $tokens[$index]->getContent() && !$this->isEqualPartOfDeclareStatement($tokens, $index) && $this->tokensAnalyzer->isBinaryOperator($index)) {
-                            $this->fixWhiteSpaceBeforeOperator($tokensClone, $index, $alignStrategy);
-                        }
-                    }
-                } else {
-                    for ($index = $tokens->count() - 2; $index > 0; --$index) {
-                        $content = $tokens[$index]->getContent();
-                        if (strtolower($content) === $tokenContent && $this->tokensAnalyzer->isBinaryOperator($index)) { // never part of declare statement
-                            $this->fixWhiteSpaceBeforeOperator($tokensClone, $index, $alignStrategy);
-                        }
-                    }
-                }
-            }
-
-            $tokens->setCode($this->replacePlaceholders($tokensClone, $alignStrategy, $tokenContent));
-        }
-    }
-
-    private function injectAlignmentPlaceholdersDefault(Tokens $tokens, int $startAt, int $endAt, string $tokenContent): void
-    {
-        $newLineFoundSinceLastPlaceholder = true;
-
-        for ($index = $startAt; $index < $endAt; ++$index) {
-            $token = $tokens[$index];
-            $content = $token->getContent();
-
-            if (str_contains($content, "\n")) {
-                $newLineFoundSinceLastPlaceholder = true;
-            }
-
-            if (
-                strtolower($content) === $tokenContent
-                && $this->tokensAnalyzer->isBinaryOperator($index)
-                && ('=' !== $content || !$this->isEqualPartOfDeclareStatement($tokens, $index))
-                && $newLineFoundSinceLastPlaceholder
-            ) {
-                $tokens[$index] = new Token(\sprintf(self::ALIGN_PLACEHOLDER, $this->currentLevel).$content);
-                $newLineFoundSinceLastPlaceholder = false;
-
-                continue;
-            }
-
-            if ($token->isGivenKind(T_FN)) {
-                $from = $tokens->getNextMeaningfulToken($index);
-                $until = $this->tokensAnalyzer->getLastTokenIndexOfArrowFunction($index);
-                $this->injectAlignmentPlaceholders($tokens, $from + 1, $until - 1, $tokenContent);
-                $index = $until;
-
-                continue;
-            }
-
-            if ($token->isGivenKind([T_FUNCTION, T_CLASS])) {
-                $index = $tokens->getNextTokenOfKind($index, ['{', ';', '(']);
-                // We don't align `=` on multi-line definition of function parameters with default values
-                if ($tokens[$index]->equals('(')) {
-                    $index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
-
-                    continue;
-                }
-
-                if ($tokens[$index]->equals(';')) {
-                    continue;
-                }
-
-                // Update the token to the `{` one in order to apply the following logic
-                $token = $tokens[$index];
-            }
-
-            if ($token->equals('{')) {
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);
-                $this->injectAlignmentPlaceholders($tokens, $index + 1, $until - 1, $tokenContent);
-                $index = $until;
-
-                continue;
-            }
-
-            if ($token->equals('(')) {
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
-                $this->injectAlignmentPlaceholders($tokens, $index + 1, $until - 1, $tokenContent);
-                $index = $until;
-
-                continue;
-            }
-
-            if ($token->equals('[')) {
-                $index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_INDEX_SQUARE_BRACE, $index);
-
-                continue;
-            }
-
-            if ($token->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_OPEN)) {
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $index);
-                $this->injectAlignmentPlaceholders($tokens, $index + 1, $until - 1, $tokenContent);
-                $index = $until;
-
-                continue;
-            }
-        }
-    }
-
-    private function injectAlignmentPlaceholders(Tokens $tokens, int $from, int $until, string $tokenContent): void
-    {
-        // Only inject placeholders for multi-line code
-        if ($tokens->isPartialCodeMultiline($from, $until)) {
-            ++$this->deepestLevel;
-            $currentLevel = $this->currentLevel;
-            $this->currentLevel = $this->deepestLevel;
-            $this->injectAlignmentPlaceholdersDefault($tokens, $from, $until, $tokenContent);
-            $this->currentLevel = $currentLevel;
-        }
-    }
-
-    private function injectAlignmentPlaceholdersForArrow(Tokens $tokens, int $startAt, int $endAt): void
-    {
-        $newLineFoundSinceLastPlaceholder = true;
-        $yieldFoundSinceLastPlaceholder = false;
-
-        for ($index = $startAt; $index < $endAt; ++$index) {
-            /** @var Token $token */
-            $token = $tokens[$index];
-            $content = $token->getContent();
-
-            if (str_contains($content, "\n")) {
-                $newLineFoundSinceLastPlaceholder = true;
-            }
-
-            if ($token->isGivenKind(T_YIELD)) {
-                $yieldFoundSinceLastPlaceholder = true;
-            }
-
-            if ($token->isGivenKind(T_FN)) {
-                $yieldFoundSinceLastPlaceholder = false;
-                $from = $tokens->getNextMeaningfulToken($index);
-                $until = $this->tokensAnalyzer->getLastTokenIndexOfArrowFunction($index);
-                $this->injectArrayAlignmentPlaceholders($tokens, $from + 1, $until - 1);
-                $index = $until;
-
-                continue;
-            }
-
-            if ($token->isGivenKind(T_ARRAY)) { // don't use "$tokens->isArray()" here, short arrays are handled in the next case
-                $yieldFoundSinceLastPlaceholder = false;
-                $from = $tokens->getNextMeaningfulToken($index);
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $from);
-                $index = $until;
-
-                $this->injectArrayAlignmentPlaceholders($tokens, $from + 1, $until - 1);
-
-                continue;
-            }
-
-            if ($token->isGivenKind(CT::T_ARRAY_SQUARE_BRACE_OPEN)) {
-                $yieldFoundSinceLastPlaceholder = false;
-                $from = $index;
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $from);
-                $index = $until;
-
-                $this->injectArrayAlignmentPlaceholders($tokens, $from + 1, $until - 1);
-
-                continue;
-            }
-
-            // no need to analyze for `isBinaryOperator` (always true), nor if part of declare statement (not valid PHP)
-            // there is also no need to analyse the second arrow of a line
-            if ($token->isGivenKind(T_DOUBLE_ARROW) && $newLineFoundSinceLastPlaceholder) {
-                if ($yieldFoundSinceLastPlaceholder) {
-                    ++$this->deepestLevel;
-                    ++$this->currentLevel;
-                }
-                $tokenContent = \sprintf(self::ALIGN_PLACEHOLDER, $this->currentLevel).$token->getContent();
-
-                $nextToken = $tokens[$index + 1];
-                if (!$nextToken->isWhitespace()) {
-                    $tokenContent .= ' ';
-                } elseif ($nextToken->isWhitespace(" \t")) {
-                    $tokens[$index + 1] = new Token([T_WHITESPACE, ' ']);
-                }
-
-                $tokens[$index] = new Token([T_DOUBLE_ARROW, $tokenContent]);
-                $newLineFoundSinceLastPlaceholder = false;
-                $yieldFoundSinceLastPlaceholder = false;
-
-                continue;
-            }
-
-            if ($token->equals(';')) {
-                ++$this->deepestLevel;
-                ++$this->currentLevel;
-
-                continue;
-            }
-
-            if ($token->equals(',')) {
-                for ($i = $index; $i < $endAt - 1; ++$i) {
-                    if (str_contains($tokens[$i - 1]->getContent(), "\n")) {
-                        $newLineFoundSinceLastPlaceholder = true;
-
-                        break;
-                    }
-
-                    if ($tokens[$i + 1]->isGivenKind([T_ARRAY, CT::T_ARRAY_SQUARE_BRACE_OPEN])) {
-                        $arrayStartIndex = $tokens[$i + 1]->isGivenKind(T_ARRAY)
-                            ? $tokens->getNextMeaningfulToken($i + 1)
-                            : $i + 1;
-                        $blockType = Tokens::detectBlockType($tokens[$arrayStartIndex]);
-                        $arrayEndIndex = $tokens->findBlockEnd($blockType['type'], $arrayStartIndex);
-
-                        if ($tokens->isPartialCodeMultiline($arrayStartIndex, $arrayEndIndex)) {
-                            break;
-                        }
-                    }
-
-                    ++$index;
-                }
-            }
-
-            if ($token->equals('{')) {
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);
-                $this->injectArrayAlignmentPlaceholders($tokens, $index + 1, $until - 1);
-                $index = $until;
-
-                continue;
-            }
-
-            if ($token->equals('(')) {
-                $until = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
-                $this->injectArrayAlignmentPlaceholders($tokens, $index + 1, $until - 1);
-                $index = $until;
-
-                continue;
-            }
-        }
-    }
-
-    private function injectArrayAlignmentPlaceholders(Tokens $tokens, int $from, int $until): void
-    {
-        // Only inject placeholders for multi-line arrays
-        if ($tokens->isPartialCodeMultiline($from, $until)) {
-            ++$this->deepestLevel;
-            $currentLevel = $this->currentLevel;
-            $this->currentLevel = $this->deepestLevel;
-            $this->injectAlignmentPlaceholdersForArrow($tokens, $from, $until);
-            $this->currentLevel = $currentLevel;
-        }
-    }
-
-    private function fixWhiteSpaceBeforeOperator(Tokens $tokens, int $index, string $alignStrategy): void
-    {
-        // fix white space after operator is not needed as BinaryOperatorSpacesFixer took care of this (if strategy is _not_ ALIGN)
-        if (!$tokens[$index - 1]->isWhitespace()) {
-            $tokens->insertAt($index, new Token([T_WHITESPACE, ' ']));
-
-            return;
-        }
-
-        if (
-            self::ALIGN_SINGLE_SPACE_MINIMAL !== $alignStrategy && self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE !== $alignStrategy
-            || $tokens[$tokens->getPrevNonWhitespace($index - 1)]->isComment()
-        ) {
-            return;
-        }
-
-        $content = $tokens[$index - 1]->getContent();
-        if (' ' !== $content && !str_contains($content, "\n")) {
-            $tokens[$index - 1] = new Token([T_WHITESPACE, ' ']);
-        }
-    }
-
-    /**
-     * Look for group of placeholders and provide vertical alignment.
-     */
-    private function replacePlaceholders(Tokens $tokens, string $alignStrategy, string $tokenContent): string
-    {
-        $tmpCode = $tokens->generateCode();
-
-        for ($j = 0; $j <= $this->deepestLevel; ++$j) {
-            $placeholder = \sprintf(self::ALIGN_PLACEHOLDER, $j);
-
-            if (!str_contains($tmpCode, $placeholder)) {
-                continue;
-            }
-
-            $lines = explode("\n", $tmpCode);
-            $groups = [];
-            $groupIndex = 0;
-            $groups[$groupIndex] = [];
-
-            foreach ($lines as $index => $line) {
-                if (substr_count($line, $placeholder) > 0) {
-                    $groups[$groupIndex][] = $index;
-                } elseif (
-                    self::ALIGN_BY_SCOPE !== $alignStrategy
-                    && self::ALIGN_SINGLE_SPACE_BY_SCOPE !== $alignStrategy
-                    && self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE !== $alignStrategy
-                ) {
-                    ++$groupIndex;
-                    $groups[$groupIndex] = [];
-                }
-            }
-
-            foreach ($groups as $group) {
-                if (\count($group) < 1) {
-                    continue;
-                }
-
-                if (self::ALIGN !== $alignStrategy) {
-                    // move placeholders to match strategy
-                    foreach ($group as $index) {
-                        $currentPosition = strpos($lines[$index], $placeholder);
-                        $before = substr($lines[$index], 0, $currentPosition);
-
-                        if (
-                            self::ALIGN_SINGLE_SPACE === $alignStrategy
-                            || self::ALIGN_SINGLE_SPACE_BY_SCOPE === $alignStrategy
-                        ) {
-                            if (!str_ends_with($before, ' ')) { // if last char of before-content is not ' '; add it
-                                $before .= ' ';
-                            }
-                        } elseif (
-                            self::ALIGN_SINGLE_SPACE_MINIMAL === $alignStrategy
-                            || self::ALIGN_SINGLE_SPACE_MINIMAL_BY_SCOPE === $alignStrategy
-                        ) {
-                            if (!Preg::match('/^\h+$/', $before)) { // if indent; do not move, leave to other fixer
-                                $before = rtrim($before).' ';
-                            }
-                        }
-
-                        $lines[$index] = $before.substr($lines[$index], $currentPosition);
-                    }
-                }
-
-                $rightmostSymbol = 0;
-                foreach ($group as $index) {
-                    $rightmostSymbol = max($rightmostSymbol, $this->getSubstringWidth($lines[$index], $placeholder));
-                }
-
-                foreach ($group as $index) {
-                    $line = $lines[$index];
-                    $currentSymbol = $this->getSubstringWidth($line, $placeholder);
-                    $delta = abs($rightmostSymbol - $currentSymbol);
-
-                    if ($delta > 0) {
-                        $line = str_replace($placeholder, str_repeat(' ', $delta).$placeholder, $line);
-                        $lines[$index] = $line;
-                    }
-                }
-            }
-
-            $tmpCode = str_replace($placeholder, '', implode("\n", $lines));
-        }
-
-        return $tmpCode;
-    }
-
-    private function getSubstringWidth(string $haystack, string $needle): int
-    {
-        $position = strpos($haystack, $needle);
-        \assert(\is_int($position));
-
-        $substring = substr($haystack, 0, $position);
-
-        return mb_strwidth($substring);
-    }
-}