File "UopzReloaderVisitor.php"
Full Path: /home/palsarh/web/palsarh.in/public_html/vendor/psy/psysh/src/ExecutionLoop/UopzReloaderVisitor.php
File size: 21.4 KB
MIME-type: text/x-php
Charset: utf-8
<?php
/*
* This file is part of Psy Shell.
*
* (c) 2012-2025 Justin Hileman
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Psy\ExecutionLoop;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Stmt;
use PhpParser\NodeVisitorAbstract;
use PhpParser\PrettyPrinter;
use ReflectionClass;
/**
* AST visitor that reloads code definitions using uopz.
*
* Traverses the parsed AST and uses uopz to reload:
* - Class methods (via uopz_set_return with closure)
* - Functions (via uopz_set_return)
* - Class and global constants (via uopz_redefine)
*
* Safety checks:
* - Conditional code (functions/constants inside if blocks) is skipped by default
* because reloading may not match runtime conditions
* - Static variables in functions/methods trigger a warning (state will reset)
* - Structural changes (new properties, inheritance) cannot be applied
*
* When force-reload is enabled (via `yolo` command), safety checks are bypassed
* and the code is reloaded anyway.
*/
class UopzReloaderVisitor extends NodeVisitorAbstract
{
private PrettyPrinter\Standard $printer;
/** @var bool Whether to bypass safety warnings */
private bool $forceReload;
private string $namespace = '';
private ?string $currentClass = null;
private ?string $currentFunction = null;
/** @var string[] Warning messages generated during traversal */
private array $warnings = [];
/** @var bool Whether any elements were skipped (not force-reloaded) */
private bool $hasSkips = false;
/** @var int Nesting depth inside conditional/control structures */
private int $conditionalDepth = 0;
/**
* @param bool $forceReload Whether to bypass safety warnings
*/
public function __construct(PrettyPrinter\Standard $printer, bool $forceReload = false)
{
$this->printer = $printer;
$this->forceReload = $forceReload;
}
/**
* Check if any warnings were generated during reloading.
*/
public function hasWarnings(): bool
{
return \count($this->warnings) > 0;
}
/**
* Get all warnings generated during reloading.
*
* @return string[]
*/
public function getWarnings(): array
{
return $this->warnings;
}
/**
* Check if any elements were skipped during reloading.
*/
public function hasSkips(): bool
{
return $this->hasSkips;
}
/**
* Add a warning message.
*/
private function addWarning(string $message): void
{
$this->warnings[] = $message;
}
/**
* {@inheritdoc}
*/
public function enterNode(Node $node)
{
// Track namespace
if ($node instanceof Stmt\Namespace_) {
$this->namespace = $node->name ? $node->name->toString() : '';
}
// Track current class and check for limitations
if ($node instanceof Stmt\Class_ || $node instanceof Stmt\Interface_ || $node instanceof Stmt\Trait_) {
$name = $node->name ? $node->name->toString() : null;
$this->currentClass = $name ? $this->getFullyQualifiedName($name) : null;
if ($this->currentClass) {
$this->checkClassLimitations($this->currentClass, $node);
}
}
// Track when we enter conditional/control structures at global scope
if ($this->currentClass === null && $this->currentFunction === null && $this->isControlStructure($node)) {
$this->conditionalDepth++;
}
// Detect side effects at global/namespace scope (but not if we're already tracking it as conditional)
if ($this->currentClass === null && $this->currentFunction === null && $this->conditionalDepth === 0) {
$this->checkForSideEffects($node);
}
// Reload class methods
if ($node instanceof Stmt\ClassMethod && $this->currentClass) {
$this->reloadMethod($this->currentClass, $node);
}
// Reload functions (skip if inside conditional, unless force mode)
if ($node instanceof Stmt\Function_) {
// Track that we're entering a function
$this->currentFunction = $node->name->toString();
if ($this->conditionalDepth > 0 && $this->currentClass === null) {
$funcName = $node->name->toString();
$snippet = \sprintf('if (...) { function %s() ... }', $funcName);
if ($this->forceReload) {
$this->addWarning(\sprintf('YOLO: Force-reloaded %s', $snippet));
$this->reloadFunction($node);
} else {
$this->addWarning(\sprintf('Skipped conditional: %s (use `yolo` to force)', $snippet));
$this->hasSkips = true;
}
} else {
$this->reloadFunction($node);
}
}
// Reload constants
if ($node instanceof Stmt\ClassConst && $this->currentClass) {
$this->reloadClassConstants($this->currentClass, $node);
}
if ($node instanceof Stmt\Const_) {
if ($this->conditionalDepth > 0 && $this->currentClass === null) {
$constNode = $node->consts[0] ?? null;
$constName = $constNode ? $constNode->name->toString() : 'CONST';
$snippet = \sprintf('if (...) { const %s = ...; }', $constName);
if ($this->forceReload) {
$this->addWarning(\sprintf('YOLO: Force-reloaded %s', $snippet));
$this->reloadGlobalConstants($node);
} else {
$this->addWarning(\sprintf('Skipped conditional: %s (use `yolo` to force)', $snippet));
$this->hasSkips = true;
}
} else {
$this->reloadGlobalConstants($node);
}
}
return null;
}
/**
* {@inheritdoc}
*/
public function leaveNode(Node $node)
{
// Clear current class when leaving class/interface/trait
if ($node instanceof Stmt\Class_ || $node instanceof Stmt\Interface_ || $node instanceof Stmt\Trait_) {
$this->currentClass = null;
}
// Clear current function when leaving function
if ($node instanceof Stmt\Function_) {
$this->currentFunction = null;
}
// Track when we leave conditional/control structures at global scope
if ($this->currentClass === null && $this->currentFunction === null && $this->isControlStructure($node)) {
$this->conditionalDepth--;
}
return null;
}
/**
* Reload a class method using uopz_set_return.
*/
private function reloadMethod(string $className, Stmt\ClassMethod $method): void
{
$methodName = $method->name->toString();
// Skip abstract methods
if ($method->isAbstract()) {
return;
}
// Check for static variables in method body
if ($this->hasStaticVariables($method->stmts)) {
$snippet = \sprintf('%s::%s() { static $var = ...; }', $className, $methodName);
$this->addWarning(\sprintf('Static vars will reset: %s', $snippet));
}
$closure = $this->createClosure($method->params, $method->stmts, $method->returnType);
if ($closure !== null) {
try {
\uopz_set_return($className, $methodName, $closure, true);
} catch (\Throwable $e) {
$this->addWarning(\sprintf('Failed to reload %s::%s(): %s', $className, $methodName, $e->getMessage()));
}
}
}
/**
* Reload a function using uopz_set_return.
*/
private function reloadFunction(Stmt\Function_ $function): void
{
$functionName = $this->getFullyQualifiedName($function->name->toString());
// New function; just define it via eval
if (!\function_exists($functionName)) {
try {
$code = '';
if ($this->namespace !== '') {
$code .= 'namespace '.$this->namespace.'; ';
}
$code .= $this->printer->prettyPrint([$function]);
eval($code);
} catch (\Throwable $e) {
$this->addWarning(\sprintf('Failed to add %s(): %s', $functionName, $e->getMessage()));
}
return;
}
// Existing function; check for static variables (state will reset on reload)
if ($this->hasStaticVariables($function->stmts)) {
$snippet = \sprintf('%s() { static $var = ...; }', $functionName);
$this->addWarning(\sprintf('Static vars will reset: %s', $snippet));
}
// Use uopz to override existing function
$closure = $this->createClosure($function->params, $function->stmts, $function->returnType);
if ($closure !== null) {
try {
\uopz_set_return($functionName, $closure, true);
} catch (\Throwable $e) {
$this->addWarning(\sprintf('Failed to reload %s(): %s', $functionName, $e->getMessage()));
}
}
}
/**
* Create a closure from parameters and statements.
*
* @param Node\Param[] $params
* @param Stmt[]|null $stmts
* @param Node|null $returnType
*
* @return \Closure|null
*/
private function createClosure(array $params, ?array $stmts, ?Node $returnType = null): ?\Closure
{
$paramStrs = [];
foreach ($params as $param) {
$paramStr = '';
if ($param->type) {
$paramStr .= $this->printer->prettyPrint([$param->type]).' ';
}
if ($param->variadic) {
$paramStr .= '...';
}
if ($param->byRef) {
$paramStr .= '&';
}
$paramStr .= '$'.$param->var->name;
if ($param->default) {
$paramStr .= ' = '.$this->printer->prettyPrintExpr($param->default);
}
$paramStrs[] = $paramStr;
}
$paramList = \implode(', ', $paramStrs);
$returnTypeStr = '';
if ($returnType !== null) {
$returnTypeStr = ': '.$this->printer->prettyPrint([$returnType]);
}
$body = '';
if ($stmts) {
$bodyStmts = [];
foreach ($stmts as $stmt) {
$bodyStmts[] = $this->printer->prettyPrint([$stmt]);
}
$body = \implode("\n", $bodyStmts);
}
$closureCode = \sprintf("return function(%s)%s {\n%s\n};", $paramList, $returnTypeStr, $body);
try {
return eval($closureCode);
} catch (\Throwable $e) {
return null;
}
}
/**
* Reload class constants using uopz_redefine.
*/
private function reloadClassConstants(string $className, Stmt\ClassConst $const): void
{
foreach ($const->consts as $constNode) {
$constName = $constNode->name->toString();
$value = $this->evaluateConstValue($constNode->value);
try {
\uopz_redefine($className, $constName, $value);
} catch (\Throwable $e) {
$this->addWarning(\sprintf('Failed to reload %s::%s: %s', $className, $constName, $e->getMessage()));
}
}
}
/**
* Reload global constants using uopz_redefine.
*/
private function reloadGlobalConstants(Stmt\Const_ $const): void
{
foreach ($const->consts as $constNode) {
$constName = $this->getFullyQualifiedName($constNode->name->toString());
$value = $this->evaluateConstValue($constNode->value);
try {
\uopz_redefine($constName, $value);
} catch (\Throwable $e) {
$this->addWarning(\sprintf('Failed to reload %s: %s', $constName, $e->getMessage()));
}
}
}
/**
* Evaluate a constant value from AST node.
*
* @return mixed
*/
private function evaluateConstValue(Expr $expr)
{
// For simple scalar values, we can evaluate directly
try {
$code = '<?php return '.$this->printer->prettyPrintExpr($expr).';';
return eval(\substr($code, 6));
} catch (\Throwable $e) {
return null;
}
}
/**
* Get a fully-qualified name (class, function, constant, etc).
*/
private function getFullyQualifiedName(string $name): string
{
if ($this->namespace && \strpos($name, '\\') !== 0) {
return $this->namespace.'\\'.$name;
}
return $name;
}
/**
* Check if a node is a control structure.
*/
private function isControlStructure(Node $node): bool
{
return $node instanceof Stmt\If_ ||
$node instanceof Stmt\Switch_ ||
$node instanceof Stmt\For_ ||
$node instanceof Stmt\Foreach_ ||
$node instanceof Stmt\While_ ||
$node instanceof Stmt\Do_ ||
$node instanceof Stmt\TryCatch;
}
/**
* Check if statements contain static variable declarations.
*
* @param Stmt[]|null $stmts
*/
private function hasStaticVariables(?array $stmts): bool
{
if ($stmts === null) {
return false;
}
foreach ($stmts as $stmt) {
// Direct static declaration
if ($stmt instanceof Stmt\Static_) {
return true;
}
// Recursively check nested structures (if/for/while/etc)
if ($stmt instanceof Stmt\If_) {
if ($this->hasStaticVariables($stmt->stmts)) {
return true;
}
foreach ($stmt->elseifs as $elseif) {
if ($this->hasStaticVariables($elseif->stmts)) {
return true;
}
}
if ($stmt->else && $this->hasStaticVariables($stmt->else->stmts)) {
return true;
}
}
if ($stmt instanceof Stmt\For_ ||
$stmt instanceof Stmt\Foreach_ ||
$stmt instanceof Stmt\While_ ||
$stmt instanceof Stmt\Do_) {
if ($this->hasStaticVariables($stmt->stmts)) {
return true;
}
}
if ($stmt instanceof Stmt\Switch_) {
foreach ($stmt->cases as $case) {
if ($this->hasStaticVariables($case->stmts)) {
return true;
}
}
}
if ($stmt instanceof Stmt\TryCatch) {
if ($this->hasStaticVariables($stmt->stmts)) {
return true;
}
foreach ($stmt->catches as $catch) {
if ($this->hasStaticVariables($catch->stmts)) {
return true;
}
}
if ($stmt->finally && $this->hasStaticVariables($stmt->finally->stmts)) {
return true;
}
}
}
return false;
}
/**
* Check for side effects that won't be re-executed on reload.
*
* Detects top-level code that has side effects (function calls, variable
* assignments, etc.) which will not be re-run when the file is reloaded.
*/
private function checkForSideEffects(Node $node): void
{
// Skip declarations (these are handled by uopz)
if ($node instanceof Stmt\Class_ ||
$node instanceof Stmt\Interface_ ||
$node instanceof Stmt\Trait_ ||
$node instanceof Stmt\Function_ ||
$node instanceof Stmt\Const_ ||
$node instanceof Stmt\Namespace_ ||
$node instanceof Stmt\Use_) {
return;
}
// Only check statements, not expressions (to avoid duplicate warnings)
// Expression statements contain the actual expression
if ($node instanceof Stmt\Expression) {
$expr = $node->expr;
$snippet = $this->printer->prettyPrintExpr($expr);
// Truncate long snippets
if (\strlen($snippet) > 50) {
$snippet = \substr($snippet, 0, 47).'...';
}
$this->addWarning(\sprintf('Not re-run: %s', $snippet));
return;
}
// Echo/print statements
if ($node instanceof Stmt\Echo_) {
$firstExpr = $node->exprs[0] ?? null;
$snippet = $firstExpr !== null
? 'echo '.$this->printer->prettyPrintExpr($firstExpr)
: 'echo ...';
if (\strlen($snippet) > 50) {
$snippet = \substr($snippet, 0, 47).'...';
}
$this->addWarning(\sprintf('Not re-run: %s', $snippet));
return;
}
// Global variable declarations
if ($node instanceof Stmt\Global_) {
$varNames = [];
foreach ($node->vars as $var) {
if ($var instanceof Expr\Variable) {
$varNames[] = '$'.$var->name;
}
}
$snippet = 'global '.\implode(', ', $varNames);
$this->addWarning(\sprintf('Not re-run: %s', $snippet));
return;
}
// Static variable declarations (inside functions are OK, but top-level would be unusual)
if ($node instanceof Stmt\Static_) {
$varNames = [];
foreach ($node->vars as $var) {
$varNames[] = '$'.$var->var->name;
}
$snippet = 'static '.\implode(', ', $varNames);
$this->addWarning(\sprintf('Not re-run: %s', $snippet));
return;
}
// If/switch/for/while/etc control structures at top level
if ($this->isControlStructure($node)) {
$type = 'if';
if ($node instanceof Stmt\Switch_) {
$type = 'switch';
} elseif ($node instanceof Stmt\For_) {
$type = 'for';
} elseif ($node instanceof Stmt\Foreach_) {
$type = 'foreach';
} elseif ($node instanceof Stmt\While_) {
$type = 'while';
} elseif ($node instanceof Stmt\Do_) {
$type = 'do-while';
} elseif ($node instanceof Stmt\TryCatch) {
$type = 'try-catch';
}
$this->addWarning(\sprintf('Not re-run: %s (...) { ... }', $type));
return;
}
}
/**
* Check for known limitations when reloading a class.
*/
private function checkClassLimitations(string $className, Node $node): void
{
// Check if class already exists
if (!\class_exists($className, false) && !\interface_exists($className, false) && !\trait_exists($className, false)) {
// New class/interface/trait - uopz cannot add these
$type = $node instanceof Stmt\Interface_ ? 'interface' : ($node instanceof Stmt\Trait_ ? 'trait' : 'class');
$this->addWarning(\sprintf('Cannot add %s %s', $type, $className));
return;
}
// For existing classes, check for structural changes
if (!($node instanceof Stmt\Class_)) {
return;
}
// Check for new properties (cannot be added)
foreach ($node->stmts as $stmt) {
if ($stmt instanceof Stmt\Property) {
foreach ($stmt->props as $prop) {
$propName = $prop->name->toString();
if (!\property_exists($className, $propName)) {
$visibility = $stmt->isPublic() ? 'public' : ($stmt->isProtected() ? 'protected' : 'private');
$static = $stmt->isStatic() ? 'static ' : '';
$this->addWarning(\sprintf('Cannot add %s$%s', $static.$visibility.' ', $propName));
}
}
}
// Check for new methods (will try to add but may fail silently)
if ($stmt instanceof Stmt\ClassMethod) {
$methodName = $stmt->name->toString();
if (!\method_exists($className, $methodName)) {
$this->addWarning(\sprintf('Cannot add %s::%s()', $className, $methodName));
}
}
}
// Check for inheritance changes
if ($node->extends) {
$newParent = $node->extends->toString();
$reflection = new ReflectionClass($className);
$currentParent = $reflection->getParentClass();
if ($currentParent && $currentParent->getName() !== $this->getFullyQualifiedName($newParent)) {
$this->addWarning(\sprintf('Cannot change parent of %s', $className));
}
}
// Check for interface changes
if ($node->implements) {
$newInterfaces = \array_map(function ($interface) {
return $this->getFullyQualifiedName($interface->toString());
}, $node->implements);
$reflection = new ReflectionClass($className);
$currentInterfaces = $reflection->getInterfaceNames();
$added = \array_diff($newInterfaces, $currentInterfaces);
$removed = \array_diff($currentInterfaces, $newInterfaces);
if (\count($added) > 0 || \count($removed) > 0) {
$this->addWarning(\sprintf('Cannot change interfaces of %s', $className));
}
}
}
}