File Manager Lite

Dir: /home/codewavebd/public_html/vendor/psy/psysh/src/CodeCleaner

[..]

AbstractClassPass.php (2.38 KB)

AssignThisVariablePass.php (1.11 KB)

CallTimePassByReferencePass.php (1.6 KB)

CalledClassPass.php (2.85 KB)

ExitPass.php (976 B)

FinalClassPass.php (1.8 KB)

FunctionContextPass.php (1.59 KB)

FunctionReturnInWriteContextPass.php (2.71 KB)

ImplicitReturnPass.php (4.54 KB)

ImplicitUsePass.php (13.08 KB)

IssetPass.php (1.4 KB)

LabelContextPass.php (2.65 KB)

LeavePsyshAlonePass.php (1014 B)

ListPass.php (2.89 KB)

LoopContextPass.php (4.01 KB)

MagicConstantsPass.php (1.06 KB)

NamespaceAwarePass.php (6.98 KB)

NamespacePass.php (3.25 KB)

NoReturnValue.php (828 B)

PassableByReferencePass.php (4.8 KB)

RequirePass.php (4.79 KB)

ReturnTypePass.php (3.73 KB)

StrictTypesPass.php (3.11 KB)

UseStatementPass.php (5.34 KB)

ValidClassNamePass.php (9.27 KB)

ValidConstructorPass.php (4.3 KB)

Edit: NamespaceAwarePass.php

<?php

/*
 * This file is part of Psy Shell.
 *
 * (c) 2012-2026 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\Name;
use PhpParser\Node\Name\FullyQualified as FullyQualifiedName;
use PhpParser\Node\Stmt\GroupUse;
use PhpParser\Node\Stmt\Namespace_;
use PhpParser\Node\Stmt\Use_;
use Psy\CodeCleaner;

/**
 * Abstract namespace-aware code cleaner pass.
 *
 * Tracks both namespace and use statement aliases for proper name resolution.
 */
abstract class NamespaceAwarePass extends CodeCleanerPass
{
    protected array $namespace = [];
    protected array $currentScope = [];
    protected array $aliases = [];
    protected array $aliasesByType = [];
    protected ?CodeCleaner $cleaner = null;

/**
     * Set the CodeCleaner instance for state management.
     */
    public function setCleaner(CodeCleaner $cleaner)
    {
        $this->cleaner = $cleaner;
    }

/**
     * @todo should this be final? Extending classes should be sure to either
     * use afterTraverse or call parent::beforeTraverse() when overloading.
     *
     * Reset the namespace and the current scope before beginning analysis
     *
     * @return Node[]|null Array of nodes
     */
    public function beforeTraverse(array $nodes)
    {
        $this->namespace = [];
        $this->currentScope = [];
        $this->aliasesByType = [];

return null;
    }

/**
     * @todo should this be final? Extending classes should be sure to either use
     * leaveNode or call parent::enterNode() when overloading
     *
     * @param Node $node
     *
     * @return int|Node|null Replacement node (or special return value)
     */
    public function enterNode(Node $node)
    {
        if ($node instanceof Namespace_) {
            $this->namespace = isset($node->name) ? $this->getParts($node->name) : [];

// Only restore use statement aliases for PsySH re-injected namespaces.
            // Explicit namespace declarations start with a clean slate.
            if ($this->cleaner && $node->getAttribute('psyshReinjected')) {
                $this->aliasesByType = $this->cleaner->getAliasesByTypeForNamespace($node->name);
                $this->aliases = $this->aliasesByType[Use_::TYPE_NORMAL] ?? [];
            } else {
                $this->aliases = [];
                $this->aliasesByType = [];
            }
        }

// Track use statements for alias resolution
        if ($node instanceof Use_) {
            foreach ($node->uses as $useItem) {
                $this->setAliasForType(\strtolower($useItem->getAlias()), $useItem->name, $this->getUseImportType($node, $useItem));
            }
        }

// Track group use statements
        if ($node instanceof GroupUse) {
            foreach ($node->uses as $useItem) {
                $this->setAliasForType(\strtolower($useItem->getAlias()), Name::concat($node->prefix, $useItem->name), $this->getUseImportType($node, $useItem));
            }
        }

return null;
    }

/**
     * Save alias state when leaving a namespace.
     *
     * Braced namespaces (like `namespace { ... }`) are self-contained and don't persist their use
     * statements between executions.
     *
     * Only save aliases for open namespaces (like `namespace Foo;`), or implicit namespace wrappers
     * re-injected by PsySH (psyshReinjected).
     *
     * {@inheritdoc}
     */
    public function leaveNode(Node $node)
    {
        if ($node instanceof Namespace_) {
            $this->syncCompatAliases();

// Open namespaces (like `namespace Foo;`) have kind == KIND_SEMICOLON.
            if ($node->getAttribute('kind') === Namespace_::KIND_SEMICOLON || $node->getAttribute('psyshReinjected')) {
                if ($this->cleaner) {
                    $this->cleaner->setAliasesByTypeForNamespace($node->name, $this->aliasesByType);
                }
            }

$this->aliases = [];
            $this->aliasesByType = [];
        }

return null;
    }

/**
     * Get a fully-qualified name (class, function, interface, etc).
     *
     * Resolves use statement aliases before applying namespace.
     *
     * @param mixed $name
     */
    protected function getFullyQualifiedName($name): string
    {
        $this->syncCompatAliases();

if ($name instanceof FullyQualifiedName) {
            return \implode('\\', $this->getParts($name));
        }

// Check if this name matches a use statement alias
        if ($name instanceof Name) {
            $nameParts = $this->getParts($name);
            $firstPart = \strtolower($nameParts[0]);

if (isset($this->aliases[$firstPart])) {
                // Replace first part with the aliased namespace
                $aliasedParts = $this->getParts($this->aliases[$firstPart]);
                \array_shift($nameParts);  // Remove first part

return \implode('\\', \array_merge($aliasedParts, $nameParts));
            }
        }

if ($name instanceof Name) {
            $name = $this->getParts($name);
        } elseif (!\is_array($name)) {
            $name = [$name];
        }

return \implode('\\', \array_merge($this->namespace, $name));
    }

/**
     * Backwards compatibility shim for PHP-Parser 4.x.
     *
     * At some point we might want to make $namespace a plain string, to match how Name works?
     */
    protected function getParts(Name $name): array
    {
        return \method_exists($name, 'getParts') ? $name->getParts() : $name->parts;
    }

protected function getAliasesForType(int $type): array
    {
        $this->syncCompatAliases();

return $this->aliasesByType[$type] ?? [];
    }

private function setAliasForType(string $alias, Name $name, int $type): void
    {
        $this->aliasesByType[$type][$alias] = $name;
        if ($type === Use_::TYPE_NORMAL) {
            $this->aliases[$alias] = $name;
        }
    }

/**
     * Sync $aliases into $aliasesByType[TYPE_NORMAL] for subclasses that read $aliases directly.
     */
    private function syncCompatAliases(): void
    {
        if ($this->aliases === []) {
            unset($this->aliasesByType[Use_::TYPE_NORMAL]);

return;
        }

$this->aliasesByType[Use_::TYPE_NORMAL] = $this->aliases;
    }

/**
     * Resolve the import type for a use item across PHP-Parser 4.x and 5.x.
     *
     * Individual use items may specify their own type (e.g. in group use
     * statements), otherwise fall back to the parent statement type.
     */
    protected function getUseImportType(Node $node, Node $useItem): int
    {
        $itemType = $useItem->type ?? null;
        if (\is_int($itemType) && $itemType !== Use_::TYPE_UNKNOWN) {
            return $itemType;
        }

$nodeType = $node->type ?? null;
        if (\is_int($nodeType) && $nodeType !== Use_::TYPE_UNKNOWN) {
            return $nodeType;
        }

return Use_::TYPE_NORMAL;
    }
}