FM / CodeCleaner

/home/techb158/ileadtechnology.com/SSM/vendor/psy/psysh/src/CodeCleaner/

/home/techb158/ileadtechnology.com/SSM/vendor/psy/psysh/src/CodeCleaner

Name	Size	Mode	Actions
AbstractClassPass.php	2200	0644	edit dl rm
AssignThisVariablePass.php	1034	0644	edit dl rm
CalledClassPass.php	2386	0644	edit dl rm
CallTimePassByReferencePass.php	1391	0644	edit dl rm
CodeCleanerPass.php	415	0644	edit dl rm
EmptyArrayDimFetchPass.php	1283	0644	edit dl rm
ExitPass.php	773	0644	edit dl rm
FinalClassPass.php	1666	0644	edit dl rm
FunctionContextPass.php	1339	0644	edit dl rm
FunctionReturnInWriteContextPass.php	2498	0644	edit dl rm
ImplicitReturnPass.php	4240	0644	edit dl rm
InstanceOfPass.php	1604	0644	edit dl rm
LabelContextPass.php	2356	0644	edit dl rm
LeavePsyshAlonePass.php	913	0644	edit dl rm
ListPass.php	3282	0644	edit dl rm
LoopContextPass.php	3476	0644	edit dl rm
MagicConstantsPass.php	1068	0644	edit dl rm
NamespaceAwarePass.php	1856	0644	edit dl rm
NamespacePass.php	2416	0644	edit dl rm
NoReturnValue.php	870	0644	edit dl rm
PassableByReferencePass.php	4024	0644	edit dl rm
RequirePass.php	3035	0644	edit dl rm
StrictTypesPass.php	2704	0644	edit dl rm
UseStatementPass.php	4356	0644	edit dl rm
ValidClassNamePass.php	12176	0644	edit dl rm
ValidConstantPass.php	3202	0644	edit dl rm
ValidConstructorPass.php	3884	0644	edit dl rm
ValidFunctionNamePass.php	3239	0644	edit dl rm

Edit: /home/techb158/ileadtechnology.com/SSM/vendor/psy/psysh/src/CodeCleaner/PassableByReferencePass.php (4024B)

<?php

/*
 * This file is part of Psy Shell.
 *
 * (c) 2012-2020 Justin Hileman
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Psy\CodeCleaner;

use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Expr\Variable;
use Psy\Exception\FatalErrorException;

/**
 * Validate that only variables (and variable-like things) are passed by reference.
 */
class PassableByReferencePass extends CodeCleanerPass
{
    const EXCEPTION_MESSAGE = 'Only variables can be passed by reference';

/**
     * @throws FatalErrorException if non-variables are passed by reference
     *
     * @param Node $node
     */
    public function enterNode(Node $node)
    {
        // @todo support MethodCall and StaticCall as well.
        if ($node instanceof FuncCall) {
            // if function name is an expression or a variable, give it a pass for now.
            if ($node->name instanceof Expr || $node->name instanceof Variable) {
                return;
            }

$name = (string) $node->name;

if ($name === 'array_multisort') {
                return $this->validateArrayMultisort($node);
            }

try {
                $refl = new \ReflectionFunction($name);
            } catch (\ReflectionException $e) {
                // Well, we gave it a shot!
                return;
            }

foreach ($refl->getParameters() as $key => $param) {
                if (\array_key_exists($key, $node->args)) {
                    $arg = $node->args[$key];
                    if ($param->isPassedByReference() && !$this->isPassableByReference($arg)) {
                        throw new FatalErrorException(self::EXCEPTION_MESSAGE, 0, E_ERROR, null, $node->getLine());
                    }
                }
            }
        }
    }

private function isPassableByReference(Node $arg)
    {
        // Unpacked arrays can be passed by reference
        if ($arg->value instanceof Array_) {
            return $arg->unpack;
        }

// FuncCall, MethodCall and StaticCall are all PHP _warnings_ not fatal errors, so we'll let
        // PHP handle those ones :)
        return $arg->value instanceof ClassConstFetch ||
            $arg->value instanceof PropertyFetch ||
            $arg->value instanceof Variable ||
            $arg->value instanceof FuncCall ||
            $arg->value instanceof MethodCall ||
            $arg->value instanceof StaticCall;
    }

/**
     * Because array_multisort has a problematic signature...
     *
     * The argument order is all sorts of wonky, and whether something is passed
     * by reference or not depends on the values of the two arguments before it.
     * We'll do a good faith attempt at validating this, but err on the side of
     * permissive.
     *
     * This is why you don't design languages where core code and extensions can
     * implement APIs that wouldn't be possible in userland code.
     *
     * @throws FatalErrorException for clearly invalid arguments
     *
     * @param Node $node
     */
    private function validateArrayMultisort(Node $node)
    {
        $nonPassable = 2; // start with 2 because the first one has to be passable by reference
        foreach ($node->args as $arg) {
            if ($this->isPassableByReference($arg)) {
                $nonPassable = 0;
            } elseif (++$nonPassable > 2) {
                // There can be *at most* two non-passable-by-reference args in a row. This is about
                // as close as we can get to validating the arguments for this function :-/
                throw new FatalErrorException(self::EXCEPTION_MESSAGE, 0, E_ERROR, null, $node->getLine());
            }
        }
    }
}

cmd: