Shell Bypass 403 GE-C666C

Ghost Exploiter Team Official

Directory >> /var/www/html/back/vendor/friendsofphp/php-cs-fixer/src/Fixer/FunctionNotation/

File / Folder	Size	Action
.	-
CombineNestedDirnameFix...	6.786KB	edt ren
DateTimeCreateFromForma...	5.941KB	edt ren
FopenFlagOrderFixer.php	3.578KB	edt ren
FopenFlagsFixer.php	4.043KB	edt ren
FunctionDeclarationFixe...	10.343KB	edt ren
FunctionTypehintSpaceFi...	1.733KB	edt ren
ImplodeCallFixer.php	4.676KB	edt ren
LambdaNotUsedImportFixe...	11.68KB	edt ren
MethodArgumentSpaceFixe...	19.087KB	edt ren
MultilinePromotedProper...	7.69KB	edt ren
NativeFunctionInvocatio...	14.639KB	edt ren
NoSpacesAfterFunctionNa...	4.797KB	edt ren
NoTrailingCommaInSingle...	1.646KB	edt ren
NoUnreachableDefaultArg...	6.181KB	edt ren
NoUselessPrintfFixer.php	3.936KB	edt ren
NoUselessSprintfFixer.php	3.553KB	edt ren
NullableTypeDeclaration...	10.129KB	edt ren
PhpdocToParamTypeFixer.php	8.478KB	edt ren
PhpdocToPropertyTypeFix...	9.78KB	edt ren
PhpdocToReturnTypeFixer...	8.651KB	edt ren
RegularCallableCallFixe...	9.303KB	edt ren
ReturnTypeDeclarationFi...	4.195KB	edt ren
SingleLineThrowFixer.php	4.711KB	edt ren
StaticLambdaFixer.php	5.286KB	edt ren
UseArrowFunctionsFixer.php	5.563KB	edt ren
VoidReturnFixer.php	7.597KB	edt ren

<?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\CT;
use PhpCsFixer\Tokenizer\Tokens;

/**
 * @author Mark Scherer
 * @author Lucas Manzke <lmanzke@outlook.com>
 * @author Gregor Harlan <gharlan@web.de>
 *
 * @no-named-arguments Parameter names are not covered by the backward compatibility promise.
 */
final class NoUnreachableDefaultArgumentValueFixer extends AbstractFixer
{
    public function getDefinition(): FixerDefinitionInterface
    {
        return new FixerDefinition(
            'In function arguments there must not be arguments with default values before non-default ones.',
            [
                new CodeSample(
                    <<<'PHP'
                        <?php
                        function example($foo = "two words", $bar) {}

PHP,
                ),
            ],
            null,
            'Modifies the signature of functions; therefore risky when using systems (such as some Symfony components) that rely on those (for example through reflection).',
        );
    }

/**
     * {@inheritdoc}
     *
     * Must run after NullableTypeDeclarationForDefaultNullValueFixer.
     */
    public function getPriority(): int
    {
        return 0;
    }

public function isCandidate(Tokens $tokens): bool
    {
        return $tokens->isAnyTokenKindsFound([\T_FUNCTION, \T_FN]);
    }

public function isRisky(): bool
    {
        return true;
    }

protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
    {
        $functionKinds = [\T_FUNCTION, \T_FN];

for ($i = 0, $l = $tokens->count(); $i < $l; ++$i) {
            if (!$tokens[$i]->isGivenKind($functionKinds)) {
                continue;
            }

$startIndex = $tokens->getNextTokenOfKind($i, ['(']);
            $i = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startIndex);

$this->fixFunctionDefinition($tokens, $startIndex, $i);
        }
    }

private function fixFunctionDefinition(Tokens $tokens, int $startIndex, int $endIndex): void
    {
        $lastArgumentIndex = $this->getLastNonDefaultArgumentIndex($tokens, $startIndex, $endIndex);

if (null === $lastArgumentIndex) {
            return;
        }

for ($i = $lastArgumentIndex; $i > $startIndex; --$i) {
            $token = $tokens[$i];

if ($token->isGivenKind(\T_VARIABLE)) {
                $lastArgumentIndex = $i;

continue;
            }

if ($token->isGivenKind(CT::T_PROPERTY_HOOK_BRACE_CLOSE)) {
                $i = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PROPERTY_HOOK, $i);

continue;
            }

if (!$token->equals('=') || $this->isNonNullableTypehintedNullableVariable($tokens, $i)) {
                continue;
            }

$this->removeDefaultValue($tokens, $i, $this->getDefaultValueEndIndex($tokens, $lastArgumentIndex));
        }
    }

private function getLastNonDefaultArgumentIndex(Tokens $tokens, int $startIndex, int $endIndex): ?int
    {
        for ($i = $endIndex - 1; $i > $startIndex; --$i) {
            $token = $tokens[$i];

if ($token->equals('=')) {
                $i = $tokens->getPrevMeaningfulToken($i);

continue;
            }

if ($token->isGivenKind(CT::T_PROPERTY_HOOK_BRACE_CLOSE)) {
                $i = $tokens->findBlockStart(Tokens::BLOCK_TYPE_PROPERTY_HOOK, $i);

continue;
            }

if ($token->isGivenKind(\T_VARIABLE) && !$tokens[$tokens->getPrevMeaningfulToken($i)]->isGivenKind(\T_ELLIPSIS)) {
                return $i;
            }
        }

return null;
    }

private function getDefaultValueEndIndex(Tokens $tokens, int $index): int
    {
        do {
            $index = $tokens->getPrevMeaningfulToken($index);

if ($tokens[$index]->isGivenKind(CT::T_ATTRIBUTE_CLOSE)) {
                $index = $tokens->findBlockStart(Tokens::BLOCK_TYPE_ATTRIBUTE, $index);
            }
        } while (!$tokens[$index]->equals(','));

return $tokens->getPrevMeaningfulToken($index);
    }

private function removeDefaultValue(Tokens $tokens, int $startIndex, int $endIndex): void
    {
        for ($i = $startIndex; $i <= $endIndex;) {
            $tokens->clearTokenAndMergeSurroundingWhitespace($i);
            $this->clearWhitespacesBeforeIndex($tokens, $i);
            $i = $tokens->getNextMeaningfulToken($i);
        }
    }

/**
     * @param int $index Index of "="
     */
    private function isNonNullableTypehintedNullableVariable(Tokens $tokens, int $index): bool
    {
        $nextToken = $tokens[$tokens->getNextMeaningfulToken($index)];

if (!$nextToken->equals([\T_STRING, 'null'], false)) {
            return false;
        }

$variableIndex = $tokens->getPrevMeaningfulToken($index);

$searchTokens = [',', '(', [\T_STRING], [CT::T_ARRAY_TYPEHINT], [\T_CALLABLE]];
        $typehintKinds = [\T_STRING, CT::T_ARRAY_TYPEHINT, \T_CALLABLE];

$prevIndex = $tokens->getPrevTokenOfKind($variableIndex, $searchTokens);

if (!$tokens[$prevIndex]->isGivenKind($typehintKinds)) {
            return false;
        }

return !$tokens[$tokens->getPrevMeaningfulToken($prevIndex)]->isGivenKind(CT::T_NULLABLE_TYPE);
    }

private function clearWhitespacesBeforeIndex(Tokens $tokens, int $index): void
    {
        $prevIndex = $tokens->getNonEmptySibling($index, -1);
        if (!$tokens[$prevIndex]->isWhitespace()) {
            return;
        }

$prevNonWhiteIndex = $tokens->getPrevNonWhitespace($prevIndex);
        if (null === $prevNonWhiteIndex || !$tokens[$prevNonWhiteIndex]->isComment()) {
            $tokens->clearTokenAndMergeSurroundingWhitespace($prevIndex);
        }
    }
}