<form method="POST">
    <h3>Editing: ReflectionCaster.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\VarDumper\Caster;

use Symfony\Component\VarDumper\Cloner\Stub;

/**
 * Casts Reflector related classes to array representation.
 *
 * @author Nicolas Grekas &lt;p@tchwork.com&gt;
 *
 * @final
 */
class ReflectionCaster
{
    public const UNSET_CLOSURE_FILE_INFO = ['Closure' =&gt; __CLASS__.'::unsetClosureFileInfo'];

    private const EXTRA_MAP = [
        'docComment' =&gt; 'getDocComment',
        'extension' =&gt; 'getExtensionName',
        'isDisabled' =&gt; 'isDisabled',
        'isDeprecated' =&gt; 'isDeprecated',
        'isInternal' =&gt; 'isInternal',
        'isUserDefined' =&gt; 'isUserDefined',
        'isGenerator' =&gt; 'isGenerator',
        'isVariadic' =&gt; 'isVariadic',
    ];

    public static function castClosure(\Closure $c, array $a, Stub $stub, bool $isNested, int $filter = 0)
    {
        $prefix = Caster::PREFIX_VIRTUAL;
        $c = new \ReflectionFunction($c);

        $a = static::castFunctionAbstract($c, $a, $stub, $isNested, $filter);

        if (!str_contains($c-&gt;name, '{closure}')) {
            $stub-&gt;class = isset($a[$prefix.'class']) ? $a[$prefix.'class']-&gt;value.'::'.$c-&gt;name : $c-&gt;name;
            unset($a[$prefix.'class']);
        }
        unset($a[$prefix.'extra']);

        $stub-&gt;class .= self::getSignature($a);

        if ($f = $c-&gt;getFileName()) {
            $stub-&gt;attr['file'] = $f;
            $stub-&gt;attr['line'] = $c-&gt;getStartLine();
        }

        unset($a[$prefix.'parameters']);

        if ($filter &amp; Caster::EXCLUDE_VERBOSE) {
            $stub-&gt;cut += ($c-&gt;getFileName() ? 2 : 0) + \count($a);

            return [];
        }

        if ($f) {
            $a[$prefix.'file'] = new LinkStub($f, $c-&gt;getStartLine());
            $a[$prefix.'line'] = $c-&gt;getStartLine().' to '.$c-&gt;getEndLine();
        }

        return $a;
    }

    public static function unsetClosureFileInfo(\Closure $c, array $a)
    {
        unset($a[Caster::PREFIX_VIRTUAL.'file'], $a[Caster::PREFIX_VIRTUAL.'line']);

        return $a;
    }

    public static function castGenerator(\Generator $c, array $a, Stub $stub, bool $isNested)
    {
        // Cannot create ReflectionGenerator based on a terminated Generator
        try {
            $reflectionGenerator = new \ReflectionGenerator($c);
        } catch (\Exception $e) {
            $a[Caster::PREFIX_VIRTUAL.'closed'] = true;

            return $a;
        }

        return self::castReflectionGenerator($reflectionGenerator, $a, $stub, $isNested);
    }

    public static function castType(\ReflectionType $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        if ($c instanceof \ReflectionNamedType || \PHP_VERSION_ID &lt; 80000) {
            $a += [
                $prefix.'name' =&gt; $c instanceof \ReflectionNamedType ? $c-&gt;getName() : (string) $c,
                $prefix.'allowsNull' =&gt; $c-&gt;allowsNull(),
                $prefix.'isBuiltin' =&gt; $c-&gt;isBuiltin(),
            ];
        } elseif ($c instanceof \ReflectionUnionType || $c instanceof \ReflectionIntersectionType) {
            $a[$prefix.'allowsNull'] = $c-&gt;allowsNull();
            self::addMap($a, $c, [
                'types' =&gt; 'getTypes',
            ]);
        } else {
            $a[$prefix.'allowsNull'] = $c-&gt;allowsNull();
        }

        return $a;
    }

    public static function castAttribute(\ReflectionAttribute $c, array $a, Stub $stub, bool $isNested)
    {
        $map = [
            'name' =&gt; 'getName',
            'arguments' =&gt; 'getArguments',
        ];

        if (\PHP_VERSION_ID &gt;= 80400) {
            unset($map['name']);
        }

        self::addMap($a, $c, $map);

        return $a;
    }

    public static function castReflectionGenerator(\ReflectionGenerator $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        if ($c-&gt;getThis()) {
            $a[$prefix.'this'] = new CutStub($c-&gt;getThis());
        }
        $function = $c-&gt;getFunction();
        $frame = [
            'class' =&gt; $function-&gt;class ?? null,
            'type' =&gt; isset($function-&gt;class) ? ($function-&gt;isStatic() ? '::' : '-&gt;') : null,
            'function' =&gt; $function-&gt;name,
            'file' =&gt; $c-&gt;getExecutingFile(),
            'line' =&gt; $c-&gt;getExecutingLine(),
        ];
        if ($trace = $c-&gt;getTrace(\DEBUG_BACKTRACE_IGNORE_ARGS)) {
            $function = new \ReflectionGenerator($c-&gt;getExecutingGenerator());
            array_unshift($trace, [
                'function' =&gt; 'yield',
                'file' =&gt; $function-&gt;getExecutingFile(),
                'line' =&gt; $function-&gt;getExecutingLine() - (int) (\PHP_VERSION_ID &lt; 80100),
            ]);
            $trace[] = $frame;
            $a[$prefix.'trace'] = new TraceStub($trace, false, 0, -1, -1);
        } else {
            $function = new FrameStub($frame, false, true);
            $function = ExceptionCaster::castFrameStub($function, [], $function, true);
            $a[$prefix.'executing'] = $function[$prefix.'src'];
        }

        $a[Caster::PREFIX_VIRTUAL.'closed'] = false;

        return $a;
    }

    public static function castClass(\ReflectionClass $c, array $a, Stub $stub, bool $isNested, int $filter = 0)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        if ($n = \Reflection::getModifierNames($c-&gt;getModifiers())) {
            $a[$prefix.'modifiers'] = implode(' ', $n);
        }

        self::addMap($a, $c, [
            'extends' =&gt; 'getParentClass',
            'implements' =&gt; 'getInterfaceNames',
            'constants' =&gt; 'getReflectionConstants',
        ]);

        foreach ($c-&gt;getProperties() as $n) {
            $a[$prefix.'properties'][$n-&gt;name] = $n;
        }

        foreach ($c-&gt;getMethods() as $n) {
            $a[$prefix.'methods'][$n-&gt;name] = $n;
        }

        self::addAttributes($a, $c, $prefix);

        if (!($filter &amp; Caster::EXCLUDE_VERBOSE) &amp;&amp; !$isNested) {
            self::addExtra($a, $c);
        }

        return $a;
    }

    public static function castFunctionAbstract(\ReflectionFunctionAbstract $c, array $a, Stub $stub, bool $isNested, int $filter = 0)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        self::addMap($a, $c, [
            'returnsReference' =&gt; 'returnsReference',
            'returnType' =&gt; 'getReturnType',
            'class' =&gt; \PHP_VERSION_ID &gt;= 80111 ? 'getClosureCalledClass' : 'getClosureScopeClass',
            'this' =&gt; 'getClosureThis',
        ]);

        if (isset($a[$prefix.'returnType'])) {
            $v = $a[$prefix.'returnType'];
            $v = $v instanceof \ReflectionNamedType ? $v-&gt;getName() : (string) $v;
            $a[$prefix.'returnType'] = new ClassStub($a[$prefix.'returnType'] instanceof \ReflectionNamedType &amp;&amp; $a[$prefix.'returnType']-&gt;allowsNull() &amp;&amp; 'mixed' !== $v ? '?'.$v : $v, [class_exists($v, false) || interface_exists($v, false) || trait_exists($v, false) ? $v : '', '']);
        }
        if (isset($a[$prefix.'class'])) {
            $a[$prefix.'class'] = new ClassStub($a[$prefix.'class']);
        }
        if (isset($a[$prefix.'this'])) {
            $a[$prefix.'this'] = new CutStub($a[$prefix.'this']);
        }

        foreach ($c-&gt;getParameters() as $v) {
            $k = '$'.$v-&gt;name;
            if ($v-&gt;isVariadic()) {
                $k = '...'.$k;
            }
            if ($v-&gt;isPassedByReference()) {
                $k = '&amp;'.$k;
            }
            $a[$prefix.'parameters'][$k] = $v;
        }
        if (isset($a[$prefix.'parameters'])) {
            $a[$prefix.'parameters'] = new EnumStub($a[$prefix.'parameters']);
        }

        self::addAttributes($a, $c, $prefix);

        if (!($filter &amp; Caster::EXCLUDE_VERBOSE) &amp;&amp; $v = $c-&gt;getStaticVariables()) {
            foreach ($v as $k =&gt; &amp;$v) {
                if (\is_object($v)) {
                    $a[$prefix.'use']['$'.$k] = new CutStub($v);
                } else {
                    $a[$prefix.'use']['$'.$k] = &amp;$v;
                }
            }
            unset($v);
            $a[$prefix.'use'] = new EnumStub($a[$prefix.'use']);
        }

        if (!($filter &amp; Caster::EXCLUDE_VERBOSE) &amp;&amp; !$isNested) {
            self::addExtra($a, $c);
        }

        return $a;
    }

    public static function castClassConstant(\ReflectionClassConstant $c, array $a, Stub $stub, bool $isNested)
    {
        $a[Caster::PREFIX_VIRTUAL.'modifiers'] = implode(' ', \Reflection::getModifierNames($c-&gt;getModifiers()));
        $a[Caster::PREFIX_VIRTUAL.'value'] = $c-&gt;getValue();

        self::addAttributes($a, $c);

        return $a;
    }

    public static function castMethod(\ReflectionMethod $c, array $a, Stub $stub, bool $isNested)
    {
        $a[Caster::PREFIX_VIRTUAL.'modifiers'] = implode(' ', \Reflection::getModifierNames($c-&gt;getModifiers()));

        return $a;
    }

    public static function castParameter(\ReflectionParameter $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        self::addMap($a, $c, [
            'position' =&gt; 'getPosition',
            'isVariadic' =&gt; 'isVariadic',
            'byReference' =&gt; 'isPassedByReference',
            'allowsNull' =&gt; 'allowsNull',
        ]);

        self::addAttributes($a, $c, $prefix);

        if ($v = $c-&gt;getType()) {
            $a[$prefix.'typeHint'] = $v instanceof \ReflectionNamedType ? $v-&gt;getName() : (string) $v;
        }

        if (isset($a[$prefix.'typeHint'])) {
            $v = $a[$prefix.'typeHint'];
            $a[$prefix.'typeHint'] = new ClassStub($v, [class_exists($v, false) || interface_exists($v, false) || trait_exists($v, false) ? $v : '', '']);
        } else {
            unset($a[$prefix.'allowsNull']);
        }

        if ($c-&gt;isOptional()) {
            try {
                $a[$prefix.'default'] = $v = $c-&gt;getDefaultValue();
                if ($c-&gt;isDefaultValueConstant() &amp;&amp; !\is_object($v)) {
                    $a[$prefix.'default'] = new ConstStub($c-&gt;getDefaultValueConstantName(), $v);
                }
                if (null === $v) {
                    unset($a[$prefix.'allowsNull']);
                }
            } catch (\ReflectionException $e) {
            }
        }

        return $a;
    }

    public static function castProperty(\ReflectionProperty $c, array $a, Stub $stub, bool $isNested)
    {
        $a[Caster::PREFIX_VIRTUAL.'modifiers'] = implode(' ', \Reflection::getModifierNames($c-&gt;getModifiers()));

        self::addAttributes($a, $c);
        self::addExtra($a, $c);

        return $a;
    }

    public static function castReference(\ReflectionReference $c, array $a, Stub $stub, bool $isNested)
    {
        $a[Caster::PREFIX_VIRTUAL.'id'] = $c-&gt;getId();

        return $a;
    }

    public static function castExtension(\ReflectionExtension $c, array $a, Stub $stub, bool $isNested)
    {
        self::addMap($a, $c, [
            'version' =&gt; 'getVersion',
            'dependencies' =&gt; 'getDependencies',
            'iniEntries' =&gt; 'getIniEntries',
            'isPersistent' =&gt; 'isPersistent',
            'isTemporary' =&gt; 'isTemporary',
            'constants' =&gt; 'getConstants',
            'functions' =&gt; 'getFunctions',
            'classes' =&gt; 'getClasses',
        ]);

        return $a;
    }

    public static function castZendExtension(\ReflectionZendExtension $c, array $a, Stub $stub, bool $isNested)
    {
        self::addMap($a, $c, [
            'version' =&gt; 'getVersion',
            'author' =&gt; 'getAuthor',
            'copyright' =&gt; 'getCopyright',
            'url' =&gt; 'getURL',
        ]);

        return $a;
    }

    public static function getSignature(array $a)
    {
        $prefix = Caster::PREFIX_VIRTUAL;
        $signature = '';

        if (isset($a[$prefix.'parameters'])) {
            foreach ($a[$prefix.'parameters']-&gt;value as $k =&gt; $param) {
                $signature .= ', ';
                if ($type = $param-&gt;getType()) {
                    if (!$type instanceof \ReflectionNamedType) {
                        $signature .= $type.' ';
                    } else {
                        if ($param-&gt;allowsNull() &amp;&amp; 'mixed' !== $type-&gt;getName()) {
                            $signature .= '?';
                        }
                        $signature .= substr(strrchr('\\'.$type-&gt;getName(), '\\'), 1).' ';
                    }
                }
                $signature .= $k;

                if (!$param-&gt;isDefaultValueAvailable()) {
                    continue;
                }
                $v = $param-&gt;getDefaultValue();
                $signature .= ' = ';

                if ($param-&gt;isDefaultValueConstant()) {
                    $signature .= substr(strrchr('\\'.$param-&gt;getDefaultValueConstantName(), '\\'), 1);
                } elseif (null === $v) {
                    $signature .= 'null';
                } elseif (\is_array($v)) {
                    $signature .= $v ? '[…'.\count($v).']' : '[]';
                } elseif (\is_string($v)) {
                    $signature .= 10 &gt; \strlen($v) &amp;&amp; !str_contains($v, '\\') ? &quot;'{$v}'&quot; : &quot;'…&quot;.\strlen($v).&quot;'&quot;;
                } elseif (\is_bool($v)) {
                    $signature .= $v ? 'true' : 'false';
                } elseif (\is_object($v)) {
                    $signature .= 'new '.substr(strrchr('\\'.get_debug_type($v), '\\'), 1);
                } else {
                    $signature .= $v;
                }
            }
        }
        $signature = (empty($a[$prefix.'returnsReference']) ? '' : '&amp;').'('.substr($signature, 2).')';

        if (isset($a[$prefix.'returnType'])) {
            $signature .= ': '.substr(strrchr('\\'.$a[$prefix.'returnType'], '\\'), 1);
        }

        return $signature;
    }

    private static function addExtra(array &amp;$a, \Reflector $c)
    {
        $x = isset($a[Caster::PREFIX_VIRTUAL.'extra']) ? $a[Caster::PREFIX_VIRTUAL.'extra']-&gt;value : [];

        if (method_exists($c, 'getFileName') &amp;&amp; $m = $c-&gt;getFileName()) {
            $x['file'] = new LinkStub($m, $c-&gt;getStartLine());
            $x['line'] = $c-&gt;getStartLine().' to '.$c-&gt;getEndLine();
        }

        self::addMap($x, $c, self::EXTRA_MAP, '');

        if ($x) {
            $a[Caster::PREFIX_VIRTUAL.'extra'] = new EnumStub($x);
        }
    }

    private static function addMap(array &amp;$a, object $c, array $map, string $prefix = Caster::PREFIX_VIRTUAL)
    {
        foreach ($map as $k =&gt; $m) {
            if (\PHP_VERSION_ID &gt;= 80000 &amp;&amp; 'isDisabled' === $k) {
                continue;
            }

            if (method_exists($c, $m) &amp;&amp; false !== ($m = $c-&gt;$m()) &amp;&amp; null !== $m) {
                $a[$prefix.$k] = $m instanceof \Reflector ? $m-&gt;name : $m;
            }
        }
    }

    private static function addAttributes(array &amp;$a, \Reflector $c, string $prefix = Caster::PREFIX_VIRTUAL): void
    {
        if (\PHP_VERSION_ID &gt;= 80000) {
            foreach ($c-&gt;getAttributes() as $n) {
                $a[$prefix.'attributes'][] = $n;
            }
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>