@averay/codeformat 0.2.1 → 0.2.3

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/ClassNotation/ProtectedToPrivateFixer.php

@@ -0,0 +1,168 @@
+<?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\ClassNotation;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+/**
+ * @author Filippo Tessarotto <zoeslam@gmail.com>
+ */
+final class ProtectedToPrivateFixer extends AbstractFixer
+{
+    private TokensAnalyzer $tokensAnalyzer;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Converts `protected` variables and methods to `private` where possible.',
+            [
+                new CodeSample(
+                    '<?php
+final class Sample
+{
+    protected $a;
+
+    protected function test()
+    {
+    }
+}
+'
+                ),
+            ]
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before OrderedClassElementsFixer.
+     * Must run after FinalClassFixer, FinalInternalClassFixer.
+     */
+    public function getPriority(): int
+    {
+        return 66;
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        if (\defined('T_ENUM') && $tokens->isAllTokenKindsFound([T_ENUM, T_PROTECTED])) { // @TODO: drop condition when PHP 8.1+ is required
+            return true;
+        }
+
+        return $tokens->isAllTokenKindsFound([T_CLASS, T_FINAL, T_PROTECTED]);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $this->tokensAnalyzer = new TokensAnalyzer($tokens);
+        $modifierKinds = [T_PUBLIC, T_PROTECTED, T_PRIVATE, T_FINAL, T_ABSTRACT, T_NS_SEPARATOR, T_STRING, CT::T_NULLABLE_TYPE, CT::T_ARRAY_TYPEHINT, T_STATIC, CT::T_TYPE_ALTERNATION, CT::T_TYPE_INTERSECTION];
+
+        if (\defined('T_READONLY')) { // @TODO: drop condition when PHP 8.1+ is required
+            $modifierKinds[] = T_READONLY;
+        }
+
+        $classesCandidate = [];
+        $classElementTypes = ['method' => true, 'property' => true, 'const' => true];
+
+        foreach ($this->tokensAnalyzer->getClassyElements() as $index => $element) {
+            $classIndex = $element['classIndex'];
+
+            $classesCandidate[$classIndex] ??= $this->isClassCandidate($tokens, $classIndex);
+
+            if (false === $classesCandidate[$classIndex]) {
+                continue;
+            }
+
+            if (!isset($classElementTypes[$element['type']])) {
+                continue;
+            }
+
+            $previous = $index;
+            $isProtected = false;
+            $isFinal = false;
+
+            do {
+                $previous = $tokens->getPrevMeaningfulToken($previous);
+
+                if ($tokens[$previous]->isGivenKind(T_PROTECTED)) {
+                    $isProtected = $previous;
+                } elseif ($tokens[$previous]->isGivenKind(T_FINAL)) {
+                    $isFinal = $previous;
+                }
+            } while ($tokens[$previous]->isGivenKind($modifierKinds));
+
+            if (false === $isProtected) {
+                continue;
+            }
+
+            if ($isFinal && 'const' === $element['type']) {
+                continue; // Final constants cannot be private
+            }
+
+            $element['protected_index'] = $isProtected;
+            $tokens[$element['protected_index']] = new Token([T_PRIVATE, 'private']);
+        }
+    }
+
+    /**
+     * Consider symbol as candidate for fixing if it's:
+     *   - an Enum (PHP8.1+)
+     *   - a class, which:
+     *     - is not anonymous
+     *     - is final
+     *     - does not use traits
+     *     - does not extend other class.
+     */
+    private function isClassCandidate(Tokens $tokens, int $classIndex): bool
+    {
+        if (\defined('T_ENUM') && $tokens[$classIndex]->isGivenKind(T_ENUM)) { // @TODO: drop condition when PHP 8.1+ is required
+            return true;
+        }
+
+        if (!$tokens[$classIndex]->isGivenKind(T_CLASS) || $this->tokensAnalyzer->isAnonymousClass($classIndex)) {
+            return false;
+        }
+
+        $modifiers = $this->tokensAnalyzer->getClassyModifiers($classIndex);
+
+        if (!isset($modifiers['final'])) {
+            return false;
+        }
+
+        $classNameIndex = $tokens->getNextMeaningfulToken($classIndex); // move to class name as anonymous class is never "final"
+        $classExtendsIndex = $tokens->getNextMeaningfulToken($classNameIndex); // move to possible "extends"
+
+        if ($tokens[$classExtendsIndex]->isGivenKind(T_EXTENDS)) {
+            return false;
+        }
+
+        if (!$tokens->isTokenKindFound(CT::T_USE_TRAIT)) {
+            return true; // cheap test
+        }
+
+        $classOpenIndex = $tokens->getNextTokenOfKind($classNameIndex, ['{']);
+        $classCloseIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $classOpenIndex);
+        $useIndex = $tokens->getNextTokenOfKind($classOpenIndex, [[CT::T_USE_TRAIT]]);
+
+        return null === $useIndex || $useIndex > $classCloseIndex;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/ClassNotation/SelfAccessorFixer.php

@@ -0,0 +1,200 @@
+<?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\ClassNotation;
+
+use PhpCsFixer\AbstractFixer;
+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;
+
+/**
+ * @author Gregor Harlan <gharlan@web.de>
+ */
+final class SelfAccessorFixer extends AbstractFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Inside class or interface element `self` should be preferred to the class name itself.',
+            [
+                new CodeSample(
+                    '<?php
+class Sample
+{
+    const BAZ = 1;
+    const BAR = Sample::BAZ;
+
+    public function getBar()
+    {
+        return Sample::BAR;
+    }
+}
+'
+                ),
+            ],
+            null,
+            'Risky when using dynamic calls like get_called_class() or late static binding.'
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isAnyTokenKindsFound([T_CLASS, T_INTERFACE]);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after PsrAutoloadingFixer.
+     */
+    public function getPriority(): int
+    {
+        return -11;
+    }
+
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $tokensAnalyzer = new TokensAnalyzer($tokens);
+
+        foreach ($tokens->getNamespaceDeclarations() as $namespace) {
+            for ($index = $namespace->getScopeStartIndex(); $index < $namespace->getScopeEndIndex(); ++$index) {
+                if (!$tokens[$index]->isGivenKind([T_CLASS, T_INTERFACE]) || $tokensAnalyzer->isAnonymousClass($index)) {
+                    continue;
+                }
+
+                $nameIndex = $tokens->getNextTokenOfKind($index, [[T_STRING]]);
+                $startIndex = $tokens->getNextTokenOfKind($nameIndex, ['{']);
+                $endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $startIndex);
+
+                $name = $tokens[$nameIndex]->getContent();
+
+                $this->replaceNameOccurrences($tokens, $namespace->getFullName(), $name, $startIndex, $endIndex);
+
+                $index = $endIndex;
+            }
+        }
+    }
+
+    /**
+     * Replace occurrences of the name of the classy element by "self" (if possible).
+     */
+    private function replaceNameOccurrences(Tokens $tokens, string $namespace, string $name, int $startIndex, int $endIndex): void
+    {
+        $tokensAnalyzer = new TokensAnalyzer($tokens);
+        $insideMethodSignatureUntil = null;
+
+        for ($i = $startIndex; $i < $endIndex; ++$i) {
+            if ($i === $insideMethodSignatureUntil) {
+                $insideMethodSignatureUntil = null;
+            }
+
+            $token = $tokens[$i];
+
+            // skip anonymous classes
+            if ($token->isGivenKind(T_CLASS) && $tokensAnalyzer->isAnonymousClass($i)) {
+                $i = $tokens->getNextTokenOfKind($i, ['{']);
+                $i = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $i);
+
+                continue;
+            }
+
+            if ($token->isGivenKind(T_FN)) {
+                $i = $tokensAnalyzer->getLastTokenIndexOfArrowFunction($i);
+                $i = $tokens->getNextMeaningfulToken($i);
+
+                continue;
+            }
+
+            if ($token->isGivenKind(T_FUNCTION)) {
+                if ($tokensAnalyzer->isLambda($i)) {
+                    $i = $tokens->getNextTokenOfKind($i, ['{']);
+                    $i = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $i);
+
+                    continue;
+                }
+
+                $i = $tokens->getNextTokenOfKind($i, ['(']);
+                $insideMethodSignatureUntil = $tokens->getNextTokenOfKind($i, ['{', ';']);
+
+                continue;
+            }
+
+            if (!$token->equals([T_STRING, $name], false)) {
+                continue;
+            }
+
+            $nextToken = $tokens[$tokens->getNextMeaningfulToken($i)];
+            if ($nextToken->isGivenKind(T_NS_SEPARATOR)) {
+                continue;
+            }
+
+            $classStartIndex = $i;
+            $prevToken = $tokens[$tokens->getPrevMeaningfulToken($i)];
+            if ($prevToken->isGivenKind(T_NS_SEPARATOR)) {
+                $classStartIndex = $this->getClassStart($tokens, $i, $namespace);
+                if (null === $classStartIndex) {
+                    continue;
+                }
+                $prevToken = $tokens[$tokens->getPrevMeaningfulToken($classStartIndex)];
+            }
+            if ($prevToken->isGivenKind(T_STRING) || $prevToken->isObjectOperator()) {
+                continue;
+            }
+
+            if (
+                $prevToken->isGivenKind([T_INSTANCEOF, T_NEW])
+                || $nextToken->isGivenKind(T_PAAMAYIM_NEKUDOTAYIM)
+                || (
+                    null !== $insideMethodSignatureUntil
+                    && $i < $insideMethodSignatureUntil
+                    && $prevToken->equalsAny(['(', ',', [CT::T_NULLABLE_TYPE], [CT::T_TYPE_ALTERNATION], [CT::T_TYPE_COLON]])
+                )
+            ) {
+                for ($j = $classStartIndex; $j < $i; ++$j) {
+                    $tokens->clearTokenAndMergeSurroundingWhitespace($j);
+                }
+                $tokens[$i] = new Token([T_STRING, 'self']);
+            }
+        }
+    }
+
+    private function getClassStart(Tokens $tokens, int $index, string $namespace): ?int
+    {
+        $namespace = ('' !== $namespace ? '\\'.$namespace : '').'\\';
+
+        foreach (array_reverse(Preg::split('/(\\\)/', $namespace, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE)) as $piece) {
+            $index = $tokens->getPrevMeaningfulToken($index);
+            if ('\\' === $piece) {
+                if (!$tokens[$index]->isGivenKind(T_NS_SEPARATOR)) {
+                    return null;
+                }
+            } elseif (!$tokens[$index]->equals([T_STRING, $piece], false)) {
+                return null;
+            }
+        }
+
+        return $index;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/ClassNotation/SelfStaticAccessorFixer.php

@@ -0,0 +1,224 @@
+<?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\ClassNotation;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\FixerDefinition\VersionSpecification;
+use PhpCsFixer\FixerDefinition\VersionSpecificCodeSample;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+final class SelfStaticAccessorFixer extends AbstractFixer
+{
+    private TokensAnalyzer $tokensAnalyzer;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Inside an enum or `final`/anonymous class, `self` should be preferred over `static`.',
+            [
+                new CodeSample(
+                    '<?php
+final class Sample
+{
+    private static $A = 1;
+
+    public function getBar()
+    {
+        return static::class.static::test().static::$A;
+    }
+
+    private static function test()
+    {
+        return \'test\';
+    }
+}
+'
+                ),
+                new CodeSample(
+                    '<?php
+final class Foo
+{
+    public function bar()
+    {
+        return new static();
+    }
+}
+'
+                ),
+                new CodeSample(
+                    '<?php
+final class Foo
+{
+    public function isBar()
+    {
+        return $foo instanceof static;
+    }
+}
+'
+                ),
+                new CodeSample(
+                    '<?php
+$a = new class() {
+    public function getBar()
+    {
+        return static::class;
+    }
+};
+'
+                ),
+                new VersionSpecificCodeSample(
+                    '<?php
+enum Foo
+{
+    public const A = 123;
+
+    public static function bar(): void
+    {
+        echo static::A;
+    }
+}
+',
+                    new VersionSpecification(8_01_00)
+                ),
+            ]
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        $classyTypes = [T_CLASS];
+
+        if (\defined('T_ENUM')) { // @TODO: drop condition when PHP 8.1+ is required
+            $classyTypes[] = T_ENUM;
+        }
+
+        return $tokens->isTokenKindFound(T_STATIC)
+            && $tokens->isAnyTokenKindsFound($classyTypes)
+            && $tokens->isAnyTokenKindsFound([T_DOUBLE_COLON, T_NEW, T_INSTANCEOF]);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after FinalClassFixer, FinalInternalClassFixer, FunctionToConstantFixer, PhpUnitTestCaseStaticMethodCallsFixer.
+     */
+    public function getPriority(): int
+    {
+        return -10;
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $classyTokensOfInterest = [[T_CLASS]];
+
+        if (\defined('T_ENUM')) {
+            $classyTokensOfInterest[] = [T_ENUM]; // @TODO drop condition when PHP 8.1+ is required
+        }
+
+        $this->tokensAnalyzer = new TokensAnalyzer($tokens);
+        $classyIndex = $tokens->getNextTokenOfKind(0, $classyTokensOfInterest);
+
+        while (null !== $classyIndex) {
+            if ($tokens[$classyIndex]->isGivenKind(T_CLASS)) {
+                $modifiers = $this->tokensAnalyzer->getClassyModifiers($classyIndex);
+
+                if (
+                    isset($modifiers['final'])
+                    || $this->tokensAnalyzer->isAnonymousClass($classyIndex)
+                ) {
+                    $classyIndex = $this->fixClassy($tokens, $classyIndex);
+                }
+            } else {
+                $classyIndex = $this->fixClassy($tokens, $classyIndex);
+            }
+
+            $classyIndex = $tokens->getNextTokenOfKind($classyIndex, $classyTokensOfInterest);
+        }
+    }
+
+    private function fixClassy(Tokens $tokens, int $index): int
+    {
+        $index = $tokens->getNextTokenOfKind($index, ['{']);
+        $classOpenCount = 1;
+
+        while ($classOpenCount > 0) {
+            ++$index;
+
+            if ($tokens[$index]->equals('{')) {
+                ++$classOpenCount;
+
+                continue;
+            }
+
+            if ($tokens[$index]->equals('}')) {
+                --$classOpenCount;
+
+                continue;
+            }
+
+            if ($tokens[$index]->isGivenKind(T_FUNCTION)) {
+                // do not fix inside lambda
+                if ($this->tokensAnalyzer->isLambda($index)) {
+                    // figure out where the lambda starts
+                    $index = $tokens->getNextTokenOfKind($index, ['{']);
+                    $openCount = 1;
+
+                    do {
+                        $index = $tokens->getNextTokenOfKind($index, ['}', '{', [T_CLASS]]);
+                        if ($tokens[$index]->equals('}')) {
+                            --$openCount;
+                        } elseif ($tokens[$index]->equals('{')) {
+                            ++$openCount;
+                        } else {
+                            $index = $this->fixClassy($tokens, $index);
+                        }
+                    } while ($openCount > 0);
+                }
+
+                continue;
+            }
+
+            if ($tokens[$index]->isGivenKind([T_NEW, T_INSTANCEOF])) {
+                $index = $tokens->getNextMeaningfulToken($index);
+
+                if ($tokens[$index]->isGivenKind(T_STATIC)) {
+                    $tokens[$index] = new Token([T_STRING, 'self']);
+                }
+
+                continue;
+            }
+
+            if (!$tokens[$index]->isGivenKind(T_STATIC)) {
+                continue;
+            }
+
+            $staticIndex = $index;
+            $index = $tokens->getNextMeaningfulToken($index);
+
+            if (!$tokens[$index]->isGivenKind(T_DOUBLE_COLON)) {
+                continue;
+            }
+
+            $tokens[$staticIndex] = new Token([T_STRING, 'self']);
+        }
+
+        return $index;
+    }
+}