@averay/codeformat 0.2.0 → 0.2.2

package/vendor/friendsofphp/php-cs-fixer/src/Tokenizer/Analyzer/ArgumentsAnalyzer.php

@@ -0,0 +1,161 @@
+<?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\Tokenizer\Analyzer;
+
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\ArgumentAnalysis;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\TypeAnalysis;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ * @author Vladimir Reznichenko <kalessil@gmail.com>
+ *
+ * @internal
+ */
+final class ArgumentsAnalyzer
+{
+    /**
+     * Count amount of parameters in a function/method reference.
+     */
+    public function countArguments(Tokens $tokens, int $openParenthesis, int $closeParenthesis): int
+    {
+        return \count($this->getArguments($tokens, $openParenthesis, $closeParenthesis));
+    }
+
+    /**
+     * Returns start and end token indices of arguments.
+     *
+     * Returns an array with each key being the first token of an
+     * argument and the value the last. Including non-function tokens
+     * such as comments and white space tokens, but without the separation
+     * tokens like '(', ',' and ')'.
+     *
+     * @return array<int, int>
+     */
+    public function getArguments(Tokens $tokens, int $openParenthesis, int $closeParenthesis): array
+    {
+        $arguments = [];
+        $firstSensibleToken = $tokens->getNextMeaningfulToken($openParenthesis);
+
+        if ($tokens[$firstSensibleToken]->equals(')')) {
+            return $arguments;
+        }
+
+        $paramContentIndex = $openParenthesis + 1;
+        $argumentsStart = $paramContentIndex;
+
+        for (; $paramContentIndex < $closeParenthesis; ++$paramContentIndex) {
+            $token = $tokens[$paramContentIndex];
+
+            // skip nested (), [], {} constructs
+            $blockDefinitionProbe = Tokens::detectBlockType($token);
+
+            if (null !== $blockDefinitionProbe && true === $blockDefinitionProbe['isStart']) {
+                $paramContentIndex = $tokens->findBlockEnd($blockDefinitionProbe['type'], $paramContentIndex);
+
+                continue;
+            }
+
+            // if comma matched, increase arguments counter
+            if ($token->equals(',')) {
+                if ($tokens->getNextMeaningfulToken($paramContentIndex) === $closeParenthesis) {
+                    break; // trailing ',' in function call (PHP 7.3)
+                }
+
+                $arguments[$argumentsStart] = $paramContentIndex - 1;
+                $argumentsStart = $paramContentIndex + 1;
+            }
+        }
+
+        $arguments[$argumentsStart] = $paramContentIndex - 1;
+
+        return $arguments;
+    }
+
+    public function getArgumentInfo(Tokens $tokens, int $argumentStart, int $argumentEnd): ArgumentAnalysis
+    {
+        static $skipTypes = null;
+
+        if (null === $skipTypes) {
+            $skipTypes = [T_ELLIPSIS, CT::T_CONSTRUCTOR_PROPERTY_PROMOTION_PUBLIC, CT::T_CONSTRUCTOR_PROPERTY_PROMOTION_PROTECTED, CT::T_CONSTRUCTOR_PROPERTY_PROMOTION_PRIVATE];
+
+            if (\defined('T_READONLY')) { // @TODO: drop condition when PHP 8.1+ is required
+                $skipTypes[] = T_READONLY;
+            }
+        }
+
+        $info = [
+            'default' => null,
+            'name' => null,
+            'name_index' => null,
+            'type' => null,
+            'type_index_start' => null,
+            'type_index_end' => null,
+        ];
+
+        $sawName = false;
+
+        for ($index = $argumentStart; $index <= $argumentEnd; ++$index) {
+            $token = $tokens[$index];
+
+            if (\defined('T_ATTRIBUTE') && $token->isGivenKind(T_ATTRIBUTE)) {
+                $index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_ATTRIBUTE, $index);
+
+                continue;
+            }
+
+            if (
+                $token->isComment()
+                || $token->isWhitespace()
+                || $token->isGivenKind($skipTypes)
+                || $token->equals('&')
+            ) {
+                continue;
+            }
+
+            if ($token->isGivenKind(T_VARIABLE)) {
+                $sawName = true;
+                $info['name_index'] = $index;
+                $info['name'] = $token->getContent();
+
+                continue;
+            }
+
+            if ($token->equals('=')) {
+                continue;
+            }
+
+            if ($sawName) {
+                $info['default'] .= $token->getContent();
+            } else {
+                $info['type_index_start'] = ($info['type_index_start'] > 0) ? $info['type_index_start'] : $index;
+                $info['type_index_end'] = $index;
+                $info['type'] .= $token->getContent();
+            }
+        }
+
+        if (null === $info['name']) {
+            $info['type'] = null;
+        }
+
+        return new ArgumentAnalysis(
+            $info['name'],
+            $info['name_index'],
+            $info['default'],
+            null !== $info['type'] ? new TypeAnalysis($info['type'], $info['type_index_start'], $info['type_index_end']) : null
+        );
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Tokenizer/Analyzer/AttributeAnalyzer.php

@@ -0,0 +1,211 @@
+<?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\Tokenizer\Analyzer;
+
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\AttributeAnalysis;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\NamespaceUseAnalysis;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @internal
+ *
+ * @phpstan-import-type _AttributeItems from AttributeAnalysis
+ */
+final class AttributeAnalyzer
+{
+    private const TOKEN_KINDS_NOT_ALLOWED_IN_ATTRIBUTE = [
+        ';',
+        '{',
+        [T_ATTRIBUTE],
+        [T_FUNCTION],
+        [T_OPEN_TAG],
+        [T_OPEN_TAG_WITH_ECHO],
+        [T_PRIVATE],
+        [T_PROTECTED],
+        [T_PUBLIC],
+        [T_RETURN],
+        [T_VARIABLE],
+        [CT::T_ATTRIBUTE_CLOSE],
+    ];
+
+    /**
+     * Check if given index is an attribute declaration.
+     */
+    public static function isAttribute(Tokens $tokens, int $index): bool
+    {
+        if (
+            !\defined('T_ATTRIBUTE') // attributes not available, PHP version lower than 8.0
+            || !$tokens[$index]->isGivenKind(T_STRING) // checked token is not a string
+            || !$tokens->isAnyTokenKindsFound([T_ATTRIBUTE]) // no attributes in the tokens collection
+        ) {
+            return false;
+        }
+
+        $attributeStartIndex = $tokens->getPrevTokenOfKind($index, self::TOKEN_KINDS_NOT_ALLOWED_IN_ATTRIBUTE);
+        if (!$tokens[$attributeStartIndex]->isGivenKind(T_ATTRIBUTE)) {
+            return false;
+        }
+
+        // now, between attribute start and the attribute candidate index cannot be more "(" than ")"
+        $count = 0;
+        for ($i = $attributeStartIndex + 1; $i < $index; ++$i) {
+            if ($tokens[$i]->equals('(')) {
+                ++$count;
+            } elseif ($tokens[$i]->equals(')')) {
+                --$count;
+            }
+        }
+
+        return 0 === $count;
+    }
+
+    /**
+     * Find all consecutive elements that start with #[ and end with ] and the attributes inside.
+     *
+     * @return list<AttributeAnalysis>
+     */
+    public static function collect(Tokens $tokens, int $index): array
+    {
+        if (!$tokens[$index]->isGivenKind(T_ATTRIBUTE)) {
+            throw new \InvalidArgumentException('Given index must point to an attribute.');
+        }
+
+        // Rewind to first attribute in group
+        while ($tokens[$prevIndex = $tokens->getPrevMeaningfulToken($index)]->isGivenKind(CT::T_ATTRIBUTE_CLOSE)) {
+            $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ATTRIBUTE, $prevIndex);
+        }
+
+        /** @var list<AttributeAnalysis> $elements */
+        $elements = [];
+
+        $openingIndex = $index;
+        do {
+            $elements[] = $element = self::collectOne($tokens, $openingIndex);
+            $openingIndex = $tokens->getNextMeaningfulToken($element->getEndIndex());
+        } while ($tokens[$openingIndex]->isGivenKind(T_ATTRIBUTE));
+
+        return $elements;
+    }
+
+    /**
+     * Find one element that starts with #[ and ends with ] and the attributes inside.
+     */
+    public static function collectOne(Tokens $tokens, int $index): AttributeAnalysis
+    {
+        if (!$tokens[$index]->isGivenKind(T_ATTRIBUTE)) {
+            throw new \InvalidArgumentException('Given index must point to an attribute.');
+        }
+
+        $startIndex = $index;
+        $prevIndex = $tokens->getPrevMeaningfulToken($index);
+
+        if ($tokens[$tokens->getPrevMeaningfulToken($index)]->isGivenKind(CT::T_ATTRIBUTE_CLOSE)) {
+            // Include comments/PHPDoc if they are present
+            $startIndex = $tokens->getNextNonWhitespace($prevIndex);
+        }
+
+        $closingIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_ATTRIBUTE, $index);
+        $endIndex = $tokens->getNextNonWhitespace($closingIndex);
+
+        return new AttributeAnalysis(
+            $startIndex,
+            $endIndex - 1,
+            $index,
+            $closingIndex,
+            self::collectAttributes($tokens, $index, $closingIndex),
+        );
+    }
+
+    public static function determineAttributeFullyQualifiedName(Tokens $tokens, string $name, int $index): string
+    {
+        if ('\\' === $name[0]) {
+            return $name;
+        }
+
+        if (!$tokens[$index]->isGivenKind([T_STRING, T_NS_SEPARATOR])) {
+            $index = $tokens->getNextTokenOfKind($index, [[T_STRING], [T_NS_SEPARATOR]]);
+        }
+
+        [$namespaceAnalysis, $namespaceUseAnalyses] = NamespacesAnalyzer::collectNamespaceAnalysis($tokens, $index);
+        $namespace = $namespaceAnalysis->getFullName();
+        $firstTokenOfName = $tokens[$index]->getContent();
+        $namespaceUseAnalysis = $namespaceUseAnalyses[$firstTokenOfName] ?? false;
+
+        if ($namespaceUseAnalysis instanceof NamespaceUseAnalysis) {
+            $namespace = $namespaceUseAnalysis->getFullName();
+
+            if ($name === $firstTokenOfName) {
+                return $namespace;
+            }
+
+            $name = substr((string) strstr($name, '\\'), 1);
+        }
+
+        return $namespace.'\\'.$name;
+    }
+
+    /**
+     * @return _AttributeItems
+     */
+    private static function collectAttributes(Tokens $tokens, int $index, int $closingIndex): array
+    {
+        $elements = [];
+
+        do {
+            $attributeStartIndex = $index + 1;
+
+            $nameStartIndex = $tokens->getNextTokenOfKind($index, [[T_STRING], [T_NS_SEPARATOR]]);
+            $index = $tokens->getNextTokenOfKind($attributeStartIndex, ['(', ',', [CT::T_ATTRIBUTE_CLOSE]]);
+            $attributeName = $tokens->generatePartialCode($nameStartIndex, $tokens->getPrevMeaningfulToken($index));
+
+            // Find closing parentheses, we need to do this in case there's a comma inside the parentheses
+            if ($tokens[$index]->equals('(')) {
+                $index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
+                $index = $tokens->getNextTokenOfKind($index, [',', [CT::T_ATTRIBUTE_CLOSE]]);
+            }
+
+            $elements[] = [
+                'start' => $attributeStartIndex,
+                'end' => $index - 1,
+                'name' => $attributeName,
+            ];
+
+            $nextIndex = $index;
+
+            // In case there's a comma right before T_ATTRIBUTE_CLOSE
+            if ($nextIndex < $closingIndex) {
+                $nextIndex = $tokens->getNextMeaningfulToken($index);
+            }
+        } while ($nextIndex < $closingIndex);
+
+        // End last element at newline if it exists and there's no trailing comma
+        --$index;
+        while ($tokens[$index]->isWhitespace()) {
+            if (Preg::match('/\R/', $tokens[$index]->getContent())) {
+                $lastElementKey = array_key_last($elements);
+                $elements[$lastElementKey]['end'] = $index - 1;
+
+                break;
+            }
+            --$index;
+        }
+
+        \assert(array_is_list($elements));
+
+        return $elements;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Tokenizer/Analyzer/BlocksAnalyzer.php

@@ -0,0 +1,59 @@
+<?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\Tokenizer\Analyzer;
+
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Kuba Werłos <werlos@gmail.com>
+ *
+ * @internal
+ */
+final class BlocksAnalyzer
+{
+    public function isBlock(Tokens $tokens, int $openIndex, int $closeIndex): bool
+    {
+        if (!$tokens->offsetExists($openIndex)) {
+            throw new \InvalidArgumentException(\sprintf('Tokex index %d for potential block opening does not exist.', $openIndex));
+        }
+
+        if (!$tokens->offsetExists($closeIndex)) {
+            throw new \InvalidArgumentException(\sprintf('Token index %d for potential block closure does not exist.', $closeIndex));
+        }
+
+        $blockType = $this->getBlockType($tokens[$openIndex]);
+
+        if (null === $blockType) {
+            return false;
+        }
+
+        return $closeIndex === $tokens->findBlockEnd($blockType, $openIndex);
+    }
+
+    /**
+     * @return Tokens::BLOCK_TYPE_*
+     */
+    private function getBlockType(Token $token): ?int
+    {
+        foreach (Tokens::getBlockEdgeDefinitions() as $blockType => $definition) {
+            if ($token->equals($definition['start'])) {
+                return $blockType;
+            }
+        }
+
+        return null;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Tokenizer/Analyzer/ClassyAnalyzer.php

@@ -0,0 +1,87 @@
+<?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\Tokenizer\Analyzer;
+
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @internal
+ */
+final class ClassyAnalyzer
+{
+    public function isClassyInvocation(Tokens $tokens, int $index): bool
+    {
+        $token = $tokens[$index];
+
+        if (!$token->isGivenKind(T_STRING)) {
+            throw new \LogicException(\sprintf('No T_STRING at given index %d, got "%s".', $index, $tokens[$index]->getName()));
+        }
+
+        if ((new Analysis\TypeAnalysis($token->getContent()))->isReservedType()) {
+            return false;
+        }
+
+        $next = $tokens->getNextMeaningfulToken($index);
+        $nextToken = $tokens[$next];
+
+        if ($nextToken->isGivenKind(T_NS_SEPARATOR)) {
+            return false;
+        }
+
+        if ($nextToken->isGivenKind([T_DOUBLE_COLON, T_ELLIPSIS, CT::T_TYPE_ALTERNATION, CT::T_TYPE_INTERSECTION, T_VARIABLE])) {
+            return true;
+        }
+
+        $prev = $tokens->getPrevMeaningfulToken($index);
+
+        while ($tokens[$prev]->isGivenKind([CT::T_NAMESPACE_OPERATOR, T_NS_SEPARATOR, T_STRING])) {
+            $prev = $tokens->getPrevMeaningfulToken($prev);
+        }
+
+        $prevToken = $tokens[$prev];
+
+        if ($prevToken->isGivenKind([T_EXTENDS, T_INSTANCEOF, T_INSTEADOF, T_IMPLEMENTS, T_NEW, CT::T_NULLABLE_TYPE, CT::T_TYPE_ALTERNATION, CT::T_TYPE_INTERSECTION, CT::T_TYPE_COLON, CT::T_USE_TRAIT])) {
+            return true;
+        }
+
+        if (\PHP_VERSION_ID >= 8_00_00 && $nextToken->equals(')') && $prevToken->equals('(') && $tokens[$tokens->getPrevMeaningfulToken($prev)]->isGivenKind(T_CATCH)) {
+            return true;
+        }
+
+        if (AttributeAnalyzer::isAttribute($tokens, $index)) {
+            return true;
+        }
+
+        // `Foo & $bar` could be:
+        //   - function reference parameter: function baz(Foo & $bar) {}
+        //   - bit operator: $x = Foo & $bar;
+        if ($nextToken->equals('&') && $tokens[$tokens->getNextMeaningfulToken($next)]->isGivenKind(T_VARIABLE)) {
+            $checkIndex = $tokens->getPrevTokenOfKind($prev + 1, [';', '{', '}', [T_FUNCTION], [T_OPEN_TAG], [T_OPEN_TAG_WITH_ECHO]]);
+
+            return $tokens[$checkIndex]->isGivenKind(T_FUNCTION);
+        }
+
+        if (!$prevToken->equals(',')) {
+            return false;
+        }
+
+        do {
+            $prev = $tokens->getPrevMeaningfulToken($prev);
+        } while ($tokens[$prev]->equalsAny([',', [T_NS_SEPARATOR], [T_STRING], [CT::T_NAMESPACE_OPERATOR]]));
+
+        return $tokens[$prev]->isGivenKind([T_IMPLEMENTS, CT::T_USE_TRAIT]);
+    }
+}