�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FPHP845%2F'>PHP845</a>/<a href='?path=%2Fbig%2FPHP845%2Flib%2F'>lib</a>/<a href='?path=%2Fbig%2FPHP845%2Flib%2Fphp%2F'>php</a>/<a href='?path=%2Fbig%2FPHP845%2Flib%2Fphp%2Fbuild%2F'>build</a>/</p><hr><h3>✏️ Editing: gen_stub.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#!/usr/bin/env php
&lt;?php declare(strict_types=1);

use PhpParser\Comment\Doc as DocComment;
use PhpParser\ConstExprEvaluator;
use PhpParser\Modifiers;
use PhpParser\Node;
use PhpParser\Node\AttributeGroup;
use PhpParser\Node\Expr;
use PhpParser\Node\Name;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\Enum_;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Trait_;
use PhpParser\PrettyPrinter\Standard;
use PhpParser\PrettyPrinterAbstract;

error_reporting(E_ALL);
ini_set(&quot;precision&quot;, &quot;-1&quot;);

const PHP_70_VERSION_ID = 70000;
const PHP_80_VERSION_ID = 80000;
const PHP_81_VERSION_ID = 80100;
const PHP_82_VERSION_ID = 80200;
const PHP_83_VERSION_ID = 80300;
const PHP_84_VERSION_ID = 80400;
const ALL_PHP_VERSION_IDS = [
    PHP_70_VERSION_ID,
    PHP_80_VERSION_ID,
    PHP_81_VERSION_ID,
    PHP_82_VERSION_ID,
    PHP_83_VERSION_ID,
    PHP_84_VERSION_ID,
];

/**
 * @return FileInfo[]
 */
function processDirectory(string $dir, Context $context): array {
    $pathNames = [];
    $it = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($dir),
        RecursiveIteratorIterator::LEAVES_ONLY
    );
    foreach ($it as $file) {
        $pathName = $file-&gt;getPathName();
        if (preg_match(&#039;/\.stub\.php$/&#039;, $pathName)) {
            $pathNames[] = $pathName;
        }
    }

    // Make sure stub files are processed in a predictable, system-independent order.
    sort($pathNames);

    $fileInfos = [];
    foreach ($pathNames as $pathName) {
        $fileInfo = processStubFile($pathName, $context);
        if ($fileInfo) {
            $fileInfos[] = $fileInfo;
        }
    }
    return $fileInfos;
}

function processStubFile(string $stubFile, Context $context, bool $includeOnly = false): ?FileInfo {
    try {
        if (!file_exists($stubFile)) {
            throw new Exception(&quot;File $stubFile does not exist&quot;);
        }

        if (!$includeOnly) {
            $stubFilenameWithoutExtension = str_replace(&quot;.stub.php&quot;, &quot;&quot;, $stubFile);
            $arginfoFile = &quot;{$stubFilenameWithoutExtension}_arginfo.h&quot;;
            $legacyFile = &quot;{$stubFilenameWithoutExtension}_legacy_arginfo.h&quot;;

            $stubCode = file_get_contents($stubFile);
            $stubHash = computeStubHash($stubCode);
            $oldStubHash = extractStubHash($arginfoFile);
            if ($stubHash === $oldStubHash &amp;&amp; !$context-&gt;forceParse) {
                /* Stub file did not change, do not regenerate. */
                return null;
            }
        }

        /* Because exit() and die() are proper token/keywords we need to hack-around */
        $hasSpecialExitAsFunctionHandling = str_ends_with($stubFile, &#039;zend_builtin_functions.stub.php&#039;);
        if (!$fileInfo = $context-&gt;parsedFiles[$stubFile] ?? null) {
            initPhpParser();
            $stubContent = $stubCode ?? file_get_contents($stubFile);
            if ($hasSpecialExitAsFunctionHandling) {
                $stubContent = str_replace([&#039;exit&#039;, &#039;die&#039;], [&#039;exit_dummy&#039;, &#039;die_dummy&#039;], $stubContent);
            }
            $fileInfo = parseStubFile($stubContent);
            $context-&gt;parsedFiles[$stubFile] = $fileInfo;

            foreach ($fileInfo-&gt;dependencies as $dependency) {
                // TODO add header search path for extensions?
                $prefixes = [dirname($stubFile) . &quot;/&quot;, dirname(__DIR__) . &quot;/&quot;];
                foreach ($prefixes as $prefix) {
                    $depFile = $prefix . $dependency;
                    if (file_exists($depFile)) {
                        break;
                    }
                    $depFile = null;
                }
                if (!$depFile) {
                    throw new Exception(&quot;File $stubFile includes a file $dependency which does not exist&quot;);
                }
                processStubFile($depFile, $context, true);
            }

            $constInfos = $fileInfo-&gt;getAllConstInfos();
            $context-&gt;allConstInfos = array_merge($context-&gt;allConstInfos, $constInfos);
        }

        if ($includeOnly) {
            return $fileInfo;
        }

        $arginfoCode = generateArgInfoCode(
            basename($stubFilenameWithoutExtension),
            $fileInfo,
            $context-&gt;allConstInfos,
            $stubHash
        );
        if ($hasSpecialExitAsFunctionHandling) {
            $arginfoCode = str_replace([&#039;exit_dummy&#039;, &#039;die_dummy&#039;], [&#039;exit&#039;, &#039;die&#039;], $arginfoCode);
        }
        if (($context-&gt;forceRegeneration || $stubHash !== $oldStubHash) &amp;&amp; file_put_contents($arginfoFile, $arginfoCode)) {
            echo &quot;Saved $arginfoFile\n&quot;;
        }

        if ($fileInfo-&gt;shouldGenerateLegacyArginfo()) {
            $legacyFileInfo = clone $fileInfo;
            $legacyFileInfo-&gt;legacyArginfoGeneration = true;
            $phpVersionIdMinimumCompatibility = $legacyFileInfo-&gt;getMinimumPhpVersionIdCompatibility();

            foreach ($legacyFileInfo-&gt;getAllFuncInfos() as $funcInfo) {
                $funcInfo-&gt;discardInfoForOldPhpVersions($phpVersionIdMinimumCompatibility);
            }
            foreach ($legacyFileInfo-&gt;getAllClassInfos() as $classInfo) {
                $classInfo-&gt;discardInfoForOldPhpVersions($phpVersionIdMinimumCompatibility);
            }
            foreach ($legacyFileInfo-&gt;getAllConstInfos() as $constInfo) {
                $constInfo-&gt;discardInfoForOldPhpVersions($phpVersionIdMinimumCompatibility);
            }

            $arginfoCode = generateArgInfoCode(
                basename($stubFilenameWithoutExtension),
                $legacyFileInfo,
                $context-&gt;allConstInfos,
                $stubHash
            );
            if (($context-&gt;forceRegeneration || $stubHash !== $oldStubHash) &amp;&amp; file_put_contents($legacyFile, $arginfoCode)) {
                echo &quot;Saved $legacyFile\n&quot;;
            }
        }

        return $fileInfo;
    } catch (Exception $e) {
        echo &quot;In $stubFile:\n{$e-&gt;getMessage()}\n&quot;;
        exit(1);
    }
}

function computeStubHash(string $stubCode): string {
    return sha1(str_replace(&quot;\r\n&quot;, &quot;\n&quot;, $stubCode));
}

function extractStubHash(string $arginfoFile): ?string {
    if (!file_exists($arginfoFile)) {
        return null;
    }

    $arginfoCode = file_get_contents($arginfoFile);
    if (!preg_match(&#039;/\* Stub hash: ([0-9a-f]+) \*/&#039;, $arginfoCode, $matches)) {
        return null;
    }

    return $matches[1];
}

class Context {
    public bool $forceParse = false;
    public bool $forceRegeneration = false;
    /** @var array&lt;string, ConstInfo&gt; */
    public array $allConstInfos = [];
    /** @var FileInfo[] */
    public array $parsedFiles = [];
}

class ArrayType extends SimpleType {
    public Type $keyType;
    public Type $valueType;

    public static function createGenericArray(): self
    {
        return new ArrayType(Type::fromString(&quot;int|string&quot;), Type::fromString(&quot;mixed|ref&quot;));
    }

    public function __construct(Type $keyType, Type $valueType)
    {
        parent::__construct(&quot;array&quot;, true);

        $this-&gt;keyType = $keyType;
        $this-&gt;valueType = $valueType;
    }

    public function toOptimizerTypeMask(): string {
        $typeMasks = [
            parent::toOptimizerTypeMask(),
            $this-&gt;keyType-&gt;toOptimizerTypeMaskForArrayKey(),
            $this-&gt;valueType-&gt;toOptimizerTypeMaskForArrayValue(),
        ];

        return implode(&quot;|&quot;, $typeMasks);
    }

    public function equals(SimpleType $other): bool {
        if (!parent::equals($other)) {
            return false;
        }

        assert(get_class($other) === self::class);

        return Type::equals($this-&gt;keyType, $other-&gt;keyType) &amp;&amp;
            Type::equals($this-&gt;valueType, $other-&gt;valueType);
    }
}

class SimpleType {
    public string $name;
    public bool $isBuiltin;

    public static function fromNode(Node $node): SimpleType {
        if ($node instanceof Node\Name) {
            if ($node-&gt;toLowerString() === &#039;static&#039;) {
                // PHP internally considers &quot;static&quot; a builtin type.
                return new SimpleType($node-&gt;toLowerString(), true);
            }

            if ($node-&gt;toLowerString() === &#039;self&#039;) {
                throw new Exception(&#039;The exact class name must be used instead of &quot;self&quot;&#039;);
            }

            assert($node-&gt;isFullyQualified());
            return new SimpleType($node-&gt;toString(), false);
        }

        if ($node instanceof Node\Identifier) {
            if ($node-&gt;toLowerString() === &#039;array&#039;) {
                return ArrayType::createGenericArray();
            }

            return new SimpleType($node-&gt;toLowerString(), true);
        }

        throw new Exception(&quot;Unexpected node type&quot;);
    }

    public static function fromString(string $typeString): SimpleType
    {
        switch (strtolower($typeString)) {
            case &quot;void&quot;:
            case &quot;null&quot;:
            case &quot;false&quot;:
            case &quot;true&quot;:
            case &quot;bool&quot;:
            case &quot;int&quot;:
            case &quot;float&quot;:
            case &quot;string&quot;:
            case &quot;callable&quot;:
            case &quot;object&quot;:
            case &quot;resource&quot;:
            case &quot;mixed&quot;:
            case &quot;static&quot;:
            case &quot;never&quot;:
            case &quot;ref&quot;:
                return new SimpleType(strtolower($typeString), true);
            case &quot;array&quot;:
                return ArrayType::createGenericArray();
            case &quot;self&quot;:
                throw new Exception(&#039;The exact class name must be used instead of &quot;self&quot;&#039;);
            case &quot;iterable&quot;:
                throw new Exception(&#039;This should not happen&#039;);
        }

        $matches = [];
        $isArray = preg_match(&quot;/(.*)\s*\[\s*\]/&quot;, $typeString, $matches);
        if ($isArray) {
            return new ArrayType(Type::fromString(&quot;int&quot;), Type::fromString($matches[1]));
        }

        $matches = [];
        $isArray = preg_match(&quot;/array\s*&lt;\s*([A-Za-z0-9_|-]+)?(\s*,\s*)?([A-Za-z0-9_|-]+)?\s*&gt;/i&quot;, $typeString, $matches);
        if ($isArray) {
            if (empty($matches[1]) || empty($matches[3])) {
                throw new Exception(&quot;array&lt;&gt; type hint must have both a key and a value&quot;);
            }

            return new ArrayType(Type::fromString($matches[1]), Type::fromString($matches[3]));
        }

        return new SimpleType($typeString, false);
    }

    /**
     * @param mixed $value
     */
    public static function fromValue($value): SimpleType
    {
        switch (gettype($value)) {
            case &quot;NULL&quot;:
                return SimpleType::null();
            case &quot;boolean&quot;:
                return SimpleType::bool();
            case &quot;integer&quot;:
                return SimpleType::int();
            case &quot;double&quot;:
                return SimpleType::float();
            case &quot;string&quot;:
                return SimpleType::string();
            case &quot;array&quot;:
                return SimpleType::array();
            case &quot;object&quot;:
                return SimpleType::object();
            default:
                throw new Exception(&quot;Type \&quot;&quot; . gettype($value) . &quot;\&quot; cannot be inferred based on value&quot;);
        }
    }

    public static function null(): SimpleType
    {
        return new SimpleType(&quot;null&quot;, true);
    }

    public static function bool(): SimpleType
    {
        return new SimpleType(&quot;bool&quot;, true);
    }

    public static function int(): SimpleType
    {
        return new SimpleType(&quot;int&quot;, true);
    }

    public static function float(): SimpleType
    {
        return new SimpleType(&quot;float&quot;, true);
    }

    public static function string(): SimpleType
    {
        return new SimpleType(&quot;string&quot;, true);
    }

    public static function array(): SimpleType
    {
        return new SimpleType(&quot;array&quot;, true);
    }

    public static function object(): SimpleType
    {
        return new SimpleType(&quot;object&quot;, true);
    }

    public static function void(): SimpleType
    {
        return new SimpleType(&quot;void&quot;, true);
    }

    protected function __construct(string $name, bool $isBuiltin) {
        $this-&gt;name = $name;
        $this-&gt;isBuiltin = $isBuiltin;
    }

    public function isScalar(): bool {
        return $this-&gt;isBuiltin &amp;&amp; in_array($this-&gt;name, [&quot;null&quot;, &quot;false&quot;, &quot;true&quot;, &quot;bool&quot;, &quot;int&quot;, &quot;float&quot;], true);
    }

    public function isNull(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;null&#039;;
    }

    public function isBool(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;bool&#039;;
    }

    public function isInt(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;int&#039;;
    }

    public function isFloat(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;float&#039;;
    }

    public function isString(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;string&#039;;
    }

    public function isArray(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;array&#039;;
    }

    public function isMixed(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === &#039;mixed&#039;;
    }

    public function toTypeCode(): string {
        assert($this-&gt;isBuiltin);
        switch ($this-&gt;name) {
            case &quot;bool&quot;:
                return &quot;_IS_BOOL&quot;;
            case &quot;int&quot;:
                return &quot;IS_LONG&quot;;
            case &quot;float&quot;:
                return &quot;IS_DOUBLE&quot;;
            case &quot;string&quot;:
                return &quot;IS_STRING&quot;;
            case &quot;array&quot;:
                return &quot;IS_ARRAY&quot;;
            case &quot;object&quot;:
                return &quot;IS_OBJECT&quot;;
            case &quot;void&quot;:
                return &quot;IS_VOID&quot;;
            case &quot;callable&quot;:
                return &quot;IS_CALLABLE&quot;;
            case &quot;mixed&quot;:
                return &quot;IS_MIXED&quot;;
            case &quot;static&quot;:
                return &quot;IS_STATIC&quot;;
            case &quot;never&quot;:
                return &quot;IS_NEVER&quot;;
            case &quot;null&quot;:
                return &quot;IS_NULL&quot;;
            case &quot;false&quot;:
                return &quot;IS_FALSE&quot;;
            case &quot;true&quot;:
                return &quot;IS_TRUE&quot;;
            default:
                throw new Exception(&quot;Not implemented: $this-&gt;name&quot;);
        }
    }

    public function toTypeMask(): string {
        assert($this-&gt;isBuiltin);

        switch ($this-&gt;name) {
            case &quot;null&quot;:
                return &quot;MAY_BE_NULL&quot;;
            case &quot;false&quot;:
                return &quot;MAY_BE_FALSE&quot;;
            case &quot;true&quot;:
                return &quot;MAY_BE_TRUE&quot;;
            case &quot;bool&quot;:
                return &quot;MAY_BE_BOOL&quot;;
            case &quot;int&quot;:
                return &quot;MAY_BE_LONG&quot;;
            case &quot;float&quot;:
                return &quot;MAY_BE_DOUBLE&quot;;
            case &quot;string&quot;:
                return &quot;MAY_BE_STRING&quot;;
            case &quot;array&quot;:
                return &quot;MAY_BE_ARRAY&quot;;
            case &quot;object&quot;:
                return &quot;MAY_BE_OBJECT&quot;;
            case &quot;callable&quot;:
                return &quot;MAY_BE_CALLABLE&quot;;
            case &quot;mixed&quot;:
                return &quot;MAY_BE_ANY&quot;;
            case &quot;void&quot;:
                return &quot;MAY_BE_VOID&quot;;
            case &quot;static&quot;:
                return &quot;MAY_BE_STATIC&quot;;
            case &quot;never&quot;:
                return &quot;MAY_BE_NEVER&quot;;
            default:
                throw new Exception(&quot;Not implemented: $this-&gt;name&quot;);
        }
    }

    public function toOptimizerTypeMaskForArrayKey(): string {
        assert($this-&gt;isBuiltin);

        switch ($this-&gt;name) {
            case &quot;int&quot;:
                return &quot;MAY_BE_ARRAY_KEY_LONG&quot;;
            case &quot;string&quot;:
                return &quot;MAY_BE_ARRAY_KEY_STRING&quot;;
            default:
                throw new Exception(&quot;Type $this-&gt;name cannot be an array key&quot;);
        }
    }

    public function toOptimizerTypeMaskForArrayValue(): string {
        if (!$this-&gt;isBuiltin) {
            return &quot;MAY_BE_ARRAY_OF_OBJECT&quot;;
        }

        switch ($this-&gt;name) {
            case &quot;null&quot;:
                return &quot;MAY_BE_ARRAY_OF_NULL&quot;;
            case &quot;false&quot;:
                return &quot;MAY_BE_ARRAY_OF_FALSE&quot;;
            case &quot;true&quot;:
                return &quot;MAY_BE_ARRAY_OF_TRUE&quot;;
            case &quot;bool&quot;:
                return &quot;MAY_BE_ARRAY_OF_FALSE|MAY_BE_ARRAY_OF_TRUE&quot;;
            case &quot;int&quot;:
                return &quot;MAY_BE_ARRAY_OF_LONG&quot;;
            case &quot;float&quot;:
                return &quot;MAY_BE_ARRAY_OF_DOUBLE&quot;;
            case &quot;string&quot;:
                return &quot;MAY_BE_ARRAY_OF_STRING&quot;;
            case &quot;array&quot;:
                return &quot;MAY_BE_ARRAY_OF_ARRAY&quot;;
            case &quot;object&quot;:
                return &quot;MAY_BE_ARRAY_OF_OBJECT&quot;;
            case &quot;resource&quot;:
                return &quot;MAY_BE_ARRAY_OF_RESOURCE&quot;;
            case &quot;mixed&quot;:
                return &quot;MAY_BE_ARRAY_OF_ANY&quot;;
            case &quot;ref&quot;:
                return &quot;MAY_BE_ARRAY_OF_REF&quot;;
            default:
                throw new Exception(&quot;Type $this-&gt;name cannot be an array value&quot;);
        }
    }

    public function toOptimizerTypeMask(): string {
        if (!$this-&gt;isBuiltin) {
            return &quot;MAY_BE_OBJECT&quot;;
        }

        switch ($this-&gt;name) {
            case &quot;resource&quot;:
                return &quot;MAY_BE_RESOURCE&quot;;
            case &quot;callable&quot;:
                return &quot;MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_LONG|MAY_BE_ARRAY_OF_STRING|MAY_BE_ARRAY_OF_OBJECT|MAY_BE_OBJECT&quot;;
            case &quot;iterable&quot;:
                return &quot;MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_OBJECT&quot;;
            case &quot;mixed&quot;:
                return &quot;MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY&quot;;
        }

        return $this-&gt;toTypeMask();
    }

    public function toEscapedName(): string {
        // Escape backslashes, and also encode \u, \U, and \N to avoid compilation errors in generated macros
        return str_replace(
            [&#039;\\&#039;, &#039;\\u&#039;, &#039;\\U&#039;, &#039;\\N&#039;],
            [&#039;\\\\&#039;, &#039;\\\\165&#039;, &#039;\\\\125&#039;, &#039;\\\\116&#039;],
            $this-&gt;name
        );
    }

    public function toVarEscapedName(): string {
        return str_replace(&#039;\\&#039;, &#039;_&#039;, $this-&gt;name);
    }

    public function equals(SimpleType $other): bool {
        return $this-&gt;name === $other-&gt;name &amp;&amp; $this-&gt;isBuiltin === $other-&gt;isBuiltin;
    }
}

class Type {
    /** @var SimpleType[] */
    public array $types;
    public bool $isIntersection;

    public static function fromNode(Node $node): Type {
        if ($node instanceof Node\UnionType || $node instanceof Node\IntersectionType) {
            $nestedTypeObjects = array_map([&#039;Type&#039;, &#039;fromNode&#039;], $node-&gt;types);
            $types = [];
            foreach ($nestedTypeObjects as $typeObject) {
                array_push($types, ...$typeObject-&gt;types);
            }
            return new Type($types, ($node instanceof Node\IntersectionType));
        }

        if ($node instanceof Node\NullableType) {
            return new Type(
                [
                    ...Type::fromNode($node-&gt;type)-&gt;types,
                    SimpleType::null(),
                ],
                false
            );
        }

        if ($node instanceof Node\Identifier &amp;&amp; $node-&gt;toLowerString() === &quot;iterable&quot;) {
            return new Type(
                [
                    SimpleType::fromString(&quot;Traversable&quot;),
                    ArrayType::createGenericArray(),
                ],
                false
            );
        }

        return new Type([SimpleType::fromNode($node)], false);
    }

    public static function fromString(string $typeString): self {
        $typeString .= &quot;|&quot;;
        $simpleTypes = [];
        $simpleTypeOffset = 0;
        $inArray = false;
        $isIntersection = false;

        $typeStringLength = strlen($typeString);
        for ($i = 0; $i &lt; $typeStringLength; $i++) {
            $char = $typeString[$i];

            if ($char === &quot;&lt;&quot;) {
                $inArray = true;
                continue;
            }

            if ($char === &quot;&gt;&quot;) {
                $inArray = false;
                continue;
            }

            if ($inArray) {
                continue;
            }

            if ($char === &quot;|&quot; || $char === &quot;&amp;&quot;) {
                $isIntersection = ($char === &quot;&amp;&quot;);
                $simpleTypeName = trim(substr($typeString, $simpleTypeOffset, $i - $simpleTypeOffset));

                $simpleTypes[] = SimpleType::fromString($simpleTypeName);

                $simpleTypeOffset = $i + 1;
            }
        }

        return new Type($simpleTypes, $isIntersection);
    }

    /**
     * @param SimpleType[] $types
     */
    private function __construct(array $types, bool $isIntersection) {
        $this-&gt;types = $types;
        $this-&gt;isIntersection = $isIntersection;
    }

    public function isScalar(): bool {
        foreach ($this-&gt;types as $type) {
            if (!$type-&gt;isScalar()) {
                return false;
            }
        }

        return true;
    }

    public function isNullable(): bool {
        foreach ($this-&gt;types as $type) {
            if ($type-&gt;isNull()) {
                return true;
            }
        }

        return false;
    }

    public function getWithoutNull(): Type {
        return new Type(
            array_values(
                array_filter(
                    $this-&gt;types,
                    function(SimpleType $type) {
                        return !$type-&gt;isNull();
                    }
                )
            ),
            false
        );
    }

    public function tryToSimpleType(): ?SimpleType {
        $withoutNull = $this-&gt;getWithoutNull();
        /* type has only null */
        if (count($withoutNull-&gt;types) === 0) {
            return $this-&gt;types[0];
        }
        if (count($withoutNull-&gt;types) === 1) {
            return $withoutNull-&gt;types[0];
        }
        return null;
    }

    public function toArginfoType(): ArginfoType {
        $classTypes = [];
        $builtinTypes = [];
        foreach ($this-&gt;types as $type) {
            if ($type-&gt;isBuiltin) {
                $builtinTypes[] = $type;
            } else {
                $classTypes[] = $type;
            }
        }
        return new ArginfoType($classTypes, $builtinTypes);
    }

    public function toOptimizerTypeMask(): string {
        $optimizerTypes = [];

        foreach ($this-&gt;types as $type) {
            // TODO Support for toOptimizerMask for intersection
            $optimizerTypes[] = $type-&gt;toOptimizerTypeMask();
        }

        return implode(&quot;|&quot;, $optimizerTypes);
    }

    public function toOptimizerTypeMaskForArrayKey(): string {
        $typeMasks = [];

        foreach ($this-&gt;types as $type) {
            $typeMasks[] = $type-&gt;toOptimizerTypeMaskForArrayKey();
        }

        return implode(&quot;|&quot;, $typeMasks);
    }

    public function toOptimizerTypeMaskForArrayValue(): string {
        $typeMasks = [];

        foreach ($this-&gt;types as $type) {
            $typeMasks[] = $type-&gt;toOptimizerTypeMaskForArrayValue();
        }

        return implode(&quot;|&quot;, $typeMasks);
    }

    public function getTypeForDoc(DOMDocument $doc): DOMElement {
        if (count($this-&gt;types) &gt; 1) {
            $typeSort = $this-&gt;isIntersection ? &quot;intersection&quot; : &quot;union&quot;;
            $typeElement = $doc-&gt;createElement(&#039;type&#039;);
            $typeElement-&gt;setAttribute(&quot;class&quot;, $typeSort);

            foreach ($this-&gt;types as $type) {
                $unionTypeElement = $doc-&gt;createElement(&#039;type&#039;, $type-&gt;name);
                $typeElement-&gt;appendChild($unionTypeElement);
            }
        } else {
            $type = $this-&gt;types[0];
            $name = $type-&gt;name;

            $typeElement = $doc-&gt;createElement(&#039;type&#039;, $name);
        }

        return $typeElement;
    }

    public static function equals(?Type $a, ?Type $b): bool {
        if ($a === null || $b === null) {
            return $a === $b;
        }

        if (count($a-&gt;types) !== count($b-&gt;types)) {
            return false;
        }

        for ($i = 0; $i &lt; count($a-&gt;types); $i++) {
            if (!$a-&gt;types[$i]-&gt;equals($b-&gt;types[$i])) {
                return false;
            }
        }

        return true;
    }

    public function __toString() {
        if ($this-&gt;types === null) {
            return &#039;mixed&#039;;
        }

        $char = $this-&gt;isIntersection ? &#039;&amp;&#039; : &#039;|&#039;;
        return implode($char, array_map(
            function ($type) { return $type-&gt;name; },
            $this-&gt;types)
        );
    }
}

class ArginfoType {
    /** @var SimpleType[] $classTypes */
    public array $classTypes;
    /** @var SimpleType[] $builtinTypes */
    private array $builtinTypes;

    /**
     * @param SimpleType[] $classTypes
     * @param SimpleType[] $builtinTypes
     */
    public function __construct(array $classTypes, array $builtinTypes) {
        $this-&gt;classTypes = $classTypes;
        $this-&gt;builtinTypes = $builtinTypes;
    }

    public function hasClassType(): bool {
        return !empty($this-&gt;classTypes);
    }

    public function toClassTypeString(): string {
        return implode(&#039;|&#039;, array_map(function(SimpleType $type) {
            return $type-&gt;toEscapedName();
        }, $this-&gt;classTypes));
    }

    public function toTypeMask(): string {
        if (empty($this-&gt;builtinTypes)) {
            return &#039;0&#039;;
        }
        return implode(&#039;|&#039;, array_map(function(SimpleType $type) {
            return $type-&gt;toTypeMask();
        }, $this-&gt;builtinTypes));
    }
}

class ArgInfo {
    const SEND_BY_VAL = 0;
    const SEND_BY_REF = 1;
    const SEND_PREFER_REF = 2;

    public string $name;
    public int $sendBy;
    public bool $isVariadic;
    public ?Type $type;
    public ?Type $phpDocType;
    public ?string $defaultValue;
    /** @var AttributeInfo[] */
    public array $attributes;

    /**
     * @param AttributeInfo[] $attributes
     */
    public function __construct(
        string $name,
        int $sendBy,
        bool $isVariadic,
        ?Type $type,
        ?Type $phpDocType,
        ?string $defaultValue,
        array $attributes
    ) {
        $this-&gt;name = $name;
        $this-&gt;sendBy = $sendBy;
        $this-&gt;isVariadic = $isVariadic;
        $this-&gt;setTypes($type, $phpDocType);
        $this-&gt;defaultValue = $defaultValue;
        $this-&gt;attributes = $attributes;
    }

    public function equals(ArgInfo $other): bool {
        return $this-&gt;name === $other-&gt;name
            &amp;&amp; $this-&gt;sendBy === $other-&gt;sendBy
            &amp;&amp; $this-&gt;isVariadic === $other-&gt;isVariadic
            &amp;&amp; Type::equals($this-&gt;type, $other-&gt;type)
            &amp;&amp; $this-&gt;defaultValue === $other-&gt;defaultValue;
    }

    public function getSendByString(): string {
        switch ($this-&gt;sendBy) {
        case self::SEND_BY_VAL:
            return &quot;0&quot;;
        case self::SEND_BY_REF:
            return &quot;1&quot;;
        case self::SEND_PREFER_REF:
            return &quot;ZEND_SEND_PREFER_REF&quot;;
        }
        throw new Exception(&quot;Invalid sendBy value&quot;);
    }

    public function getMethodSynopsisType(): Type {
        if ($this-&gt;type) {
            return $this-&gt;type;
        }

        if ($this-&gt;phpDocType) {
            return $this-&gt;phpDocType;
        }

        throw new Exception(&quot;A parameter must have a type&quot;);
    }

    public function hasProperDefaultValue(): bool {
        return $this-&gt;defaultValue !== null &amp;&amp; $this-&gt;defaultValue !== &quot;UNKNOWN&quot;;
    }

    public function getDefaultValueAsArginfoString(): string {
        if ($this-&gt;hasProperDefaultValue()) {
            return &#039;&quot;&#039; . addslashes($this-&gt;defaultValue) . &#039;&quot;&#039;;
        }

        return &quot;NULL&quot;;
    }

    public function getDefaultValueAsMethodSynopsisString(): ?string {
        if ($this-&gt;defaultValue === null) {
            return null;
        }

        switch ($this-&gt;defaultValue) {
            case &#039;UNKNOWN&#039;:
                return null;
            case &#039;false&#039;:
            case &#039;true&#039;:
            case &#039;null&#039;:
                return &quot;&amp;{$this-&gt;defaultValue};&quot;;
        }

        return $this-&gt;defaultValue;
    }

    private function setTypes(?Type $type, ?Type $phpDocType): void
    {
        $this-&gt;type = $type;
        $this-&gt;phpDocType = $phpDocType;
    }
}

interface VariableLikeName {
    public function __toString(): string;
    public function getDeclarationName(): string;
}

interface ConstOrClassConstName extends VariableLikeName {
    public function equals(ConstOrClassConstName $const): bool;
    public function isClassConst(): bool;
    public function isUnknown(): bool;
}

abstract class AbstractConstName implements ConstOrClassConstName
{
    public function equals(ConstOrClassConstName $const): bool
    {
        return $this-&gt;__toString() === $const-&gt;__toString();
    }

    public function isUnknown(): bool
    {
        return strtolower($this-&gt;__toString()) === &quot;unknown&quot;;
    }
}

class ConstName extends AbstractConstName {
    public string $const;

    public function __construct(?Name $namespace, string $const)
    {
        if ($namespace &amp;&amp; ($namespace = $namespace-&gt;slice(0, -1))) {
            $const = $namespace-&gt;toString() . &#039;\\&#039; . $const;
        }
        $this-&gt;const = $const;
    }

    public function isClassConst(): bool
    {
        return false;
    }

    public function isUnknown(): bool
    {
        $name = $this-&gt;__toString();
        if (($pos = strrpos($name, &#039;\\&#039;)) !== false) {
            $name = substr($name, $pos + 1);
        }
        return strtolower($name) === &quot;unknown&quot;;
    }

    public function __toString(): string
    {
        return $this-&gt;const;
    }

    public function getDeclarationName(): string
    {
        return $this-&gt;name-&gt;toString();
    }
}

class ClassConstName extends AbstractConstName {
    public Name $class;
    public string $const;

    public function __construct(Name $class, string $const)
    {
        $this-&gt;class = $class;
        $this-&gt;const = $const;
    }

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

    public function __toString(): string
    {
        return $this-&gt;class-&gt;toString() . &quot;::&quot; . $this-&gt;const;
    }

    public function getDeclarationName(): string
    {
        return $this-&gt;const;
    }
}

class PropertyName implements VariableLikeName {
    public Name $class;
    public string $property;

    public function __construct(Name $class, string $property)
    {
        $this-&gt;class = $class;
        $this-&gt;property = $property;
    }

    public function __toString(): string
    {
        return $this-&gt;class-&gt;toString() . &quot;::$&quot; . $this-&gt;property;
    }

    public function getDeclarationName(): string
    {
         return $this-&gt;property;
    }
}

interface FunctionOrMethodName {
    public function getDeclaration(): string;
    public function getArgInfoName(): string;
    public function getMethodSynopsisFilename(): string;
    public function getNameForAttributes(): string;
    public function __toString(): string;
    public function isMethod(): bool;
    public function isConstructor(): bool;
    public function isDestructor(): bool;
}

class FunctionName implements FunctionOrMethodName {
    private Name $name;

    public function __construct(Name $name) {
        $this-&gt;name = $name;
    }

    public function getNamespace(): ?string {
        if ($this-&gt;name-&gt;isQualified()) {
            return $this-&gt;name-&gt;slice(0, -1)-&gt;toString();
        }
        return null;
    }

    public function getNonNamespacedName(): string {
        if ($this-&gt;name-&gt;isQualified()) {
            throw new Exception(&quot;Namespaced name not supported here&quot;);
        }
        return $this-&gt;name-&gt;toString();
    }

    public function getDeclarationName(): string {
        return implode(&#039;_&#039;, $this-&gt;name-&gt;getParts());
    }

    public function getFunctionName(): string {
        return $this-&gt;name-&gt;getLast();
    }

    public function getDeclaration(): string {
        return &quot;ZEND_FUNCTION({$this-&gt;getDeclarationName()});\n&quot;;
    }

    public function getArgInfoName(): string {
        $underscoreName = implode(&#039;_&#039;, $this-&gt;name-&gt;getParts());
        return &quot;arginfo_$underscoreName&quot;;
    }

    public function getFramelessFunctionInfosName(): string {
        $underscoreName = implode(&#039;_&#039;, $this-&gt;name-&gt;getParts());
        return &quot;frameless_function_infos_$underscoreName&quot;;
    }

    public function getMethodSynopsisFilename(): string {
        return &#039;functions/&#039; . implode(&#039;/&#039;, str_replace(&#039;_&#039;, &#039;-&#039;, $this-&gt;name-&gt;getParts()));
    }

    public function getNameForAttributes(): string {
        return strtolower($this-&gt;name-&gt;toString());
    }

    public function __toString(): string {
        return $this-&gt;name-&gt;toString();
    }

    public function isMethod(): bool {
        return false;
    }

    public function isConstructor(): bool {
        return false;
    }

    public function isDestructor(): bool {
        return false;
    }
}

class MethodName implements FunctionOrMethodName {
    public Name $className;
    public string $methodName;

    public function __construct(Name $className, string $methodName) {
        $this-&gt;className = $className;
        $this-&gt;methodName = $methodName;
    }

    public function getDeclarationClassName(): string {
        return implode(&#039;_&#039;, $this-&gt;className-&gt;getParts());
    }

    public function getDeclaration(): string {
        return &quot;ZEND_METHOD({$this-&gt;getDeclarationClassName()}, $this-&gt;methodName);\n&quot;;
    }

    public function getArgInfoName(): string {
        return &quot;arginfo_class_{$this-&gt;getDeclarationClassName()}_{$this-&gt;methodName}&quot;;
    }

    public function getMethodSynopsisFilename(): string
    {
        $parts = [...$this-&gt;className-&gt;getParts(), ltrim($this-&gt;methodName, &#039;_&#039;)];
        /* File paths are in lowercase */
        return strtolower(implode(&#039;/&#039;, $parts));
    }

    public function getNameForAttributes(): string {
        return strtolower($this-&gt;methodName);
    }

    public function __toString(): string {
        return &quot;$this-&gt;className::$this-&gt;methodName&quot;;
    }

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

    public function isConstructor(): bool {
        return $this-&gt;methodName === &quot;__construct&quot;;
    }

    public function isDestructor(): bool {
        return $this-&gt;methodName === &quot;__destruct&quot;;
    }
}

class ReturnInfo {
    const REFCOUNT_0 = &quot;0&quot;;
    const REFCOUNT_1 = &quot;1&quot;;
    const REFCOUNT_N = &quot;N&quot;;

    const REFCOUNTS = [
        self::REFCOUNT_0,
        self::REFCOUNT_1,
        self::REFCOUNT_N,
    ];

    public bool $byRef;
    public ?Type $type;
    public ?Type $phpDocType;
    public bool $tentativeReturnType;
    public string $refcount;

    public function __construct(bool $byRef, ?Type $type, ?Type $phpDocType, bool $tentativeReturnType, ?string $refcount) {
        $this-&gt;byRef = $byRef;
        $this-&gt;setTypes($type, $phpDocType, $tentativeReturnType);
        $this-&gt;setRefcount($refcount);
    }

    public function equalsApartFromPhpDocAndRefcount(ReturnInfo $other): bool {
        return $this-&gt;byRef === $other-&gt;byRef
            &amp;&amp; Type::equals($this-&gt;type, $other-&gt;type)
            &amp;&amp; $this-&gt;tentativeReturnType === $other-&gt;tentativeReturnType;
    }

    public function getMethodSynopsisType(): ?Type {
        return $this-&gt;type ?? $this-&gt;phpDocType;
    }

    private function setTypes(?Type $type, ?Type $phpDocType, bool $tentativeReturnType): void
    {
        $this-&gt;type = $type;
        $this-&gt;phpDocType = $phpDocType;
        $this-&gt;tentativeReturnType = $tentativeReturnType;
    }

    private function setRefcount(?string $refcount): void
    {
        $type = $this-&gt;phpDocType ?? $this-&gt;type;
        $isScalarType = $type !== null &amp;&amp; $type-&gt;isScalar();

        if ($refcount === null) {
            $this-&gt;refcount = $isScalarType ? self::REFCOUNT_0 : self::REFCOUNT_N;
            return;
        }

        if (!in_array($refcount, ReturnInfo::REFCOUNTS, true)) {
            throw new Exception(&quot;@refcount must have one of the following values: \&quot;0\&quot;, \&quot;1\&quot;, \&quot;N\&quot;, $refcount given&quot;);
        }

        if ($isScalarType &amp;&amp; $refcount !== self::REFCOUNT_0) {
            throw new Exception(&#039;A scalar return type of &quot;&#039; . $type-&gt;__toString() . &#039;&quot; must have a refcount of &quot;&#039; . self::REFCOUNT_0 . &#039;&quot;&#039;);
        }

        if (!$isScalarType &amp;&amp; $refcount === self::REFCOUNT_0) {
            throw new Exception(&#039;A non-scalar return type of &quot;&#039; . $type-&gt;__toString() . &#039;&quot; cannot have a refcount of &quot;&#039; . self::REFCOUNT_0 . &#039;&quot;&#039;);
        }

        $this-&gt;refcount = $refcount;
    }
}

class FuncInfo {
    public FunctionOrMethodName $name;
    public int $classFlags;
    public int $flags;
    public ?string $aliasType;
    public ?FunctionOrMethodName $alias;
    public bool $isDeprecated;
    public bool $supportsCompileTimeEval;
    public bool $verify;
    /** @var ArgInfo[] */
    public array $args;
    public ReturnInfo $return;
    public int $numRequiredArgs;
    public ?string $cond;
    public bool $isUndocumentable;
    public ?int $minimumPhpVersionIdCompatibility;
    /** @var AttributeInfo[] */
    public array $attributes;
    /** @var FramelessFunctionInfo[] */
    public array $framelessFunctionInfos;
    public ?ExposedDocComment $exposedDocComment;

    /**
     * @param ArgInfo[] $args
     * @param AttributeInfo[] $attribute
     * @param FramelessFunctionInfo[] $framelessFunctionInfos
     */
    public function __construct(
        FunctionOrMethodName $name,
        int $classFlags,
        int $flags,
        ?string $aliasType,
        ?FunctionOrMethodName $alias,
        bool $isDeprecated,
        bool $supportsCompileTimeEval,
        bool $verify,
        array $args,
        ReturnInfo $return,
        int $numRequiredArgs,
        ?string $cond,
        bool $isUndocumentable,
        ?int $minimumPhpVersionIdCompatibility,
        array $attributes,
        array $framelessFunctionInfos,
        ?ExposedDocComment $exposedDocComment
    ) {
        $this-&gt;name = $name;
        $this-&gt;classFlags = $classFlags;
        $this-&gt;flags = $flags;
        $this-&gt;aliasType = $aliasType;
        $this-&gt;alias = $alias;
        $this-&gt;isDeprecated = $isDeprecated;
        $this-&gt;supportsCompileTimeEval = $supportsCompileTimeEval;
        $this-&gt;verify = $verify;
        $this-&gt;args = $args;
        $this-&gt;return = $return;
        $this-&gt;numRequiredArgs = $numRequiredArgs;
        $this-&gt;cond = $cond;
        $this-&gt;isUndocumentable = $isUndocumentable;
        $this-&gt;minimumPhpVersionIdCompatibility = $minimumPhpVersionIdCompatibility;
        $this-&gt;attributes = $attributes;
        $this-&gt;framelessFunctionInfos = $framelessFunctionInfos;
        $this-&gt;exposedDocComment = $exposedDocComment;
    }

    public function isMethod(): bool
    {
        return $this-&gt;name-&gt;isMethod();
    }

    public function isFinalMethod(): bool
    {
        return ($this-&gt;flags &amp; Modifiers::FINAL) || ($this-&gt;classFlags &amp; Modifiers::FINAL);
    }

    public function isInstanceMethod(): bool
    {
        return !($this-&gt;flags &amp; Modifiers::STATIC) &amp;&amp; $this-&gt;isMethod() &amp;&amp; !$this-&gt;name-&gt;isConstructor();
    }

    /** @return string[] */
    public function getModifierNames(): array
    {
        if (!$this-&gt;isMethod()) {
            return [];
        }

        $result = [];

        if ($this-&gt;flags &amp; Modifiers::FINAL) {
            $result[] = &quot;final&quot;;
        } elseif ($this-&gt;flags &amp; Modifiers::ABSTRACT &amp;&amp; $this-&gt;classFlags &amp; ~Modifiers::ABSTRACT) {
            $result[] = &quot;abstract&quot;;
        }

        if ($this-&gt;flags &amp; Modifiers::PROTECTED) {
            $result[] = &quot;protected&quot;;
        } elseif ($this-&gt;flags &amp; Modifiers::PRIVATE) {
            $result[] = &quot;private&quot;;
        } else {
            $result[] = &quot;public&quot;;
        }

        if ($this-&gt;flags &amp; Modifiers::STATIC) {
            $result[] = &quot;static&quot;;
        }

        return $result;
    }

    public function hasParamWithUnknownDefaultValue(): bool
    {
        foreach ($this-&gt;args as $arg) {
            if ($arg-&gt;defaultValue &amp;&amp; !$arg-&gt;hasProperDefaultValue()) {
                return true;
            }
        }

        return false;
    }

    public function equalsApartFromNameAndRefcount(FuncInfo $other): bool {
        if (count($this-&gt;args) !== count($other-&gt;args)) {
            return false;
        }

        for ($i = 0; $i &lt; count($this-&gt;args); $i++) {
            if (!$this-&gt;args[$i]-&gt;equals($other-&gt;args[$i])) {
                return false;
            }
        }

        return $this-&gt;return-&gt;equalsApartFromPhpDocAndRefcount($other-&gt;return)
            &amp;&amp; $this-&gt;numRequiredArgs === $other-&gt;numRequiredArgs
            &amp;&amp; $this-&gt;cond === $other-&gt;cond;
    }

    public function getArgInfoName(): string {
        return $this-&gt;name-&gt;getArgInfoName();
    }

    public function getDeclarationKey(): string
    {
        $name = $this-&gt;alias ?? $this-&gt;name;

        return &quot;$name|$this-&gt;cond&quot;;
    }

    public function getDeclaration(): ?string
    {
        if ($this-&gt;flags &amp; Modifiers::ABSTRACT) {
            return null;
        }

        $name = $this-&gt;alias ?? $this-&gt;name;

        return $name-&gt;getDeclaration();
    }

    public function getFramelessDeclaration(FuncInfo $funcInfo): ?string {
        if (empty($this-&gt;framelessFunctionInfos)) {
            return null;
        }

        $php84MinimumCompatibility = $this-&gt;minimumPhpVersionIdCompatibility === null || $this-&gt;minimumPhpVersionIdCompatibility &gt;= PHP_84_VERSION_ID;

        $code = &#039;&#039;;

        if (!$php84MinimumCompatibility) {
            $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_84_VERSION_ID . &quot;)\n&quot;;
        }

        foreach ($this-&gt;framelessFunctionInfos as $framelessFunctionInfo) {
            $code .= &quot;ZEND_FRAMELESS_FUNCTION({$this-&gt;name-&gt;getFunctionName()}, {$framelessFunctionInfo-&gt;arity});\n&quot;;
        }

        $code .= &#039;static const zend_frameless_function_info &#039; . $this-&gt;getFramelessFunctionInfosName() . &quot;[] = {\n&quot;;
        foreach ($this-&gt;framelessFunctionInfos as $framelessFunctionInfo) {
            $code .= &quot;\t{ ZEND_FRAMELESS_FUNCTION_NAME({$this-&gt;name-&gt;getFunctionName()}, {$framelessFunctionInfo-&gt;arity}), {$framelessFunctionInfo-&gt;arity} },\n&quot;;
        }
        $code .= &quot;\t{ 0 },\n&quot;;
        $code .= &quot;};\n&quot;;

        if (!$php84MinimumCompatibility) {
            $code .= &quot;#endif\n&quot;;
        }

        return $code;
    }

    public function getFramelessFunctionInfosName(): string {
        return $this-&gt;name-&gt;getFramelessFunctionInfosName();
    }

    public function getFunctionEntry(): string {
        $code = &quot;&quot;;

        $php84MinimumCompatibility = $this-&gt;minimumPhpVersionIdCompatibility === null || $this-&gt;minimumPhpVersionIdCompatibility &gt;= PHP_84_VERSION_ID;
        $isVanillaEntry = $this-&gt;alias === null &amp;&amp; !$this-&gt;supportsCompileTimeEval &amp;&amp; $this-&gt;exposedDocComment === null &amp;&amp; empty($this-&gt;framelessFunctionInfos);
        $argInfoName = $this-&gt;getArgInfoName();
        $flagsByPhpVersions = $this-&gt;getArginfoFlagsByPhpVersions();
        $functionEntryCode = null;

        if (!empty($this-&gt;framelessFunctionInfos)) {
            if ($this-&gt;isMethod()) {
                throw new Exception(&#039;Frameless methods are not supported yet&#039;);
            }
            if ($this-&gt;name-&gt;getNamespace()) {
                throw new Exception(&#039;Namespaced direct calls to frameless functions are not supported yet&#039;);
            }
            if ($this-&gt;alias) {
                throw new Exception(&#039;Aliased direct calls to frameless functions are not supported yet&#039;);
            }
        }

        if ($this-&gt;isMethod()) {
            $zendName = &#039;&quot;&#039; . $this-&gt;name-&gt;methodName . &#039;&quot;&#039;;
            if ($this-&gt;alias) {
                if ($this-&gt;alias instanceof MethodName) {
                    $name = &quot;zim_&quot; . $this-&gt;alias-&gt;getDeclarationClassName() . &quot;_&quot; . $this-&gt;alias-&gt;methodName;
                } else if ($this-&gt;alias instanceof FunctionName) {
                    $name = &quot;zif_&quot; . $this-&gt;alias-&gt;getNonNamespacedName();
                } else {
                    throw new Error(&quot;Cannot happen&quot;);
                }
            } else {
                if ($this-&gt;flags &amp; Modifiers::ABSTRACT) {
                    $name = &quot;NULL&quot;;
                } else {
                    $name = &quot;zim_&quot; . $this-&gt;name-&gt;getDeclarationClassName() . &quot;_&quot; . $this-&gt;name-&gt;methodName;

                    if ($isVanillaEntry) {
                        $functionEntryCode = &quot;\tZEND_ME(&quot; . $this-&gt;name-&gt;getDeclarationClassName() . &quot;, &quot; . $this-&gt;name-&gt;methodName . &quot;, $argInfoName, &quot; . implode(&quot;|&quot;, reset($flagsByPhpVersions)) . &quot;)&quot;;
                    }
                }
            }
        } else if ($this-&gt;name instanceof FunctionName) {
            $functionName = $this-&gt;name-&gt;getFunctionName();
            $declarationName = $this-&gt;alias ? $this-&gt;alias-&gt;getNonNamespacedName() : $this-&gt;name-&gt;getDeclarationName();

            if ($this-&gt;name-&gt;getNamespace()) {
                $namespace = addslashes($this-&gt;name-&gt;getNamespace());
                $zendName = &quot;ZEND_NS_NAME(\&quot;$namespace\&quot;, \&quot;$functionName\&quot;)&quot;;
                $name = &quot;zif_$declarationName&quot;;
            } else {
                $zendName = &#039;&quot;&#039; . $functionName . &#039;&quot;&#039;;
                $name = &quot;zif_$declarationName&quot;;

                if ($isVanillaEntry &amp;&amp; reset($flagsByPhpVersions) === [&quot;0&quot;]) {
                    $functionEntryCode = &quot;\tZEND_FE($declarationName, $argInfoName)&quot;;
                }
            }
        } else {
            throw new Error(&quot;Cannot happen&quot;);
        }

        if ($functionEntryCode !== null) {
            $code .= &quot;$functionEntryCode\n&quot;;
        } else {
            if (!$php84MinimumCompatibility) {
                $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_84_VERSION_ID . &quot;)\n&quot;;
            }

            $php84AndAboveFlags = array_slice($flagsByPhpVersions, 5, null, true);
            $docComment = $this-&gt;exposedDocComment ? &#039;&quot;&#039; . $this-&gt;exposedDocComment-&gt;escape() . &#039;&quot;&#039; : &quot;NULL&quot;;
            $framelessFuncInfosName = !empty($this-&gt;framelessFunctionInfos) ? $this-&gt;getFramelessFunctionInfosName() : &quot;NULL&quot;;

            $template = &quot;\tZEND_RAW_FENTRY($zendName, $name, $argInfoName, %s, $framelessFuncInfosName, $docComment)\n&quot;;
            $flagsCode = generateVersionDependentFlagCode(
                $template,
                $php84AndAboveFlags,
                PHP_84_VERSION_ID
            );
            $code .= implode(&quot;&quot;, $flagsCode);

            if (!$php84MinimumCompatibility) {
                $code .= &quot;#else\n&quot;;
            }

            if (!$php84MinimumCompatibility) {
                $flags = array_slice($flagsByPhpVersions, 0, 4, true);
                $template = &quot;\tZEND_RAW_FENTRY($zendName, $name, $argInfoName, %s)\n&quot;;
                $flagsCode = generateVersionDependentFlagCode(
                    $template,
                    $flags,
                    $this-&gt;minimumPhpVersionIdCompatibility
                );
                $code .= implode(&quot;&quot;, $flagsCode);
            }

            if (!$php84MinimumCompatibility) {
                $code .= &quot;#endif\n&quot;;
            }
        }

        return $code;
    }

    public function getOptimizerInfo(): ?string {
        if ($this-&gt;isMethod()) {
            return null;
        }

        if ($this-&gt;alias !== null) {
            return null;
        }

        if ($this-&gt;return-&gt;refcount !== ReturnInfo::REFCOUNT_1 &amp;&amp; $this-&gt;return-&gt;phpDocType === null) {
            return null;
        }

        $type = $this-&gt;return-&gt;phpDocType ?? $this-&gt;return-&gt;type;
        if ($type === null) {
            return null;
        }

        return &quot;\tF&quot; . $this-&gt;return-&gt;refcount . &#039;(&quot;&#039; . addslashes($this-&gt;name-&gt;__toString()) . &#039;&quot;, &#039; . $type-&gt;toOptimizerTypeMask() . &quot;),\n&quot;;
    }

    public function discardInfoForOldPhpVersions(?int $minimumPhpVersionIdCompatibility): void {
        $this-&gt;attributes = [];
        $this-&gt;return-&gt;type = null;
        $this-&gt;framelessFunctionInfos = [];
        $this-&gt;exposedDocComment = null;
        $this-&gt;supportsCompileTimeEval = false;
        foreach ($this-&gt;args as $arg) {
            $arg-&gt;type = null;
            $arg-&gt;defaultValue = null;
            $arg-&gt;attributes = [];
        }
        $this-&gt;minimumPhpVersionIdCompatibility = $minimumPhpVersionIdCompatibility;
    }

    /** @return array&lt;int, string[]&gt; */
    private function getArginfoFlagsByPhpVersions(): array
    {
        $flags = [];

        if ($this-&gt;isMethod()) {
            if ($this-&gt;flags &amp; Modifiers::PROTECTED) {
                $flags[] = &quot;ZEND_ACC_PROTECTED&quot;;
            } elseif ($this-&gt;flags &amp; Modifiers::PRIVATE) {
                $flags[] = &quot;ZEND_ACC_PRIVATE&quot;;
            } else {
                $flags[] = &quot;ZEND_ACC_PUBLIC&quot;;
            }

            if ($this-&gt;flags &amp; Modifiers::STATIC) {
                $flags[] = &quot;ZEND_ACC_STATIC&quot;;
            }

            if ($this-&gt;flags &amp; Modifiers::FINAL) {
                $flags[] = &quot;ZEND_ACC_FINAL&quot;;
            }

            if ($this-&gt;flags &amp; Modifiers::ABSTRACT) {
                $flags[] = &quot;ZEND_ACC_ABSTRACT&quot;;
            }
        }

        if ($this-&gt;isDeprecated) {
            $flags[] = &quot;ZEND_ACC_DEPRECATED&quot;;
        }

        foreach ($this-&gt;attributes as $attr) {
            if ($attr-&gt;class === &quot;Deprecated&quot;) {
                $flags[] = &quot;ZEND_ACC_DEPRECATED&quot;;
                break;
            }
        }

        $php82AndAboveFlags = $flags;
        if ($this-&gt;isMethod() === false &amp;&amp; $this-&gt;supportsCompileTimeEval) {
            $php82AndAboveFlags[] = &quot;ZEND_ACC_COMPILE_TIME_EVAL&quot;;
        }

        if (empty($flags)) {
            $flags[] = &quot;0&quot;;
        }
        if (empty($php82AndAboveFlags)) {
            $php82AndAboveFlags[] = &quot;0&quot;;
        }

        return [
            PHP_70_VERSION_ID =&gt; $flags,
            PHP_80_VERSION_ID =&gt; $flags,
            PHP_81_VERSION_ID =&gt; $flags,
            PHP_82_VERSION_ID =&gt; $php82AndAboveFlags,
            PHP_83_VERSION_ID =&gt; $php82AndAboveFlags,
            PHP_84_VERSION_ID =&gt; $php82AndAboveFlags,
        ];
    }

    private function generateRefSect1(DOMDocument $doc, string $role): DOMElement {
        $refSec = $doc-&gt;createElement(&#039;refsect1&#039;);
        $refSec-&gt;setAttribute(&#039;role&#039;, $role);
        $refSec-&gt;append(
            &quot;\n  &quot;,
            $doc-&gt;createEntityReference(&#039;reftitle.&#039; . $role),
            &quot;\n  &quot;
        );
        return $refSec;
    }

    /**
     * @param array&lt;string, FuncInfo&gt; $funcMap
     * @param array&lt;string, FuncInfo&gt; $aliasMap
     * @throws Exception
     */
    public function getMethodSynopsisDocument(array $funcMap, array $aliasMap): ?string {
        $REFSEC1_SEPERATOR = &quot;\n\n &quot;;

        $doc = new DOMDocument(&quot;1.0&quot;, &quot;utf-8&quot;);
        $doc-&gt;formatOutput = true;

        $refentry = $doc-&gt;createElement(&#039;refentry&#039;);
        $doc-&gt;appendChild($refentry);

        if ($this-&gt;isMethod()) {
            assert($this-&gt;name instanceof MethodName);
            /* Namespaces are seperated by &#039;-&#039;, &#039;_&#039; must be converted to &#039;-&#039; too.
             * Trim away the __ for magic methods */
            $id = strtolower(
                str_replace(&#039;\\&#039;, &#039;-&#039;, $this-&gt;name-&gt;className-&gt;__toString())
                . &#039;.&#039;
                . str_replace(&#039;_&#039;, &#039;-&#039;, ltrim($this-&gt;name-&gt;methodName, &#039;_&#039;))
            );
        } else {
            $id = &#039;function.&#039; . strtolower(str_replace(&#039;_&#039;, &#039;-&#039;, $this-&gt;name-&gt;__toString()));
        }
        $refentry-&gt;setAttribute(&quot;xml:id&quot;, $id);
        /* We create an attribute for xmlns, as libxml otherwise force it to be the first one */
        //$refentry-&gt;setAttribute(&quot;xmlns&quot;, &quot;http://docbook.org/ns/docbook&quot;);
        $namespace = $doc-&gt;createAttribute(&#039;xmlns&#039;);
        $namespace-&gt;value = &quot;http://docbook.org/ns/docbook&quot;;
        $refentry-&gt;setAttributeNode($namespace);
        $refentry-&gt;setAttribute(&quot;xmlns:xlink&quot;, &quot;http://www.w3.org/1999/xlink&quot;);
        $refentry-&gt;appendChild(new DOMText(&quot;\n &quot;));

        /* Creation of &lt;refnamediv&gt; */
        $refnamediv = $doc-&gt;createElement(&#039;refnamediv&#039;);
        $refnamediv-&gt;appendChild(new DOMText(&quot;\n  &quot;));
        $refname = $doc-&gt;createElement(&#039;refname&#039;, $this-&gt;name-&gt;__toString());
        $refnamediv-&gt;appendChild($refname);
        $refnamediv-&gt;appendChild(new DOMText(&quot;\n  &quot;));
        $refpurpose = $doc-&gt;createElement(&#039;refpurpose&#039;, &#039;Description&#039;);
        $refnamediv-&gt;appendChild($refpurpose);

        $refnamediv-&gt;appendChild(new DOMText(&quot;\n &quot;));
        $refentry-&gt;append($refnamediv, $REFSEC1_SEPERATOR);

        /* Creation of &lt;refsect1 role=&quot;description&quot;&gt; */
        $descriptionRefSec = $this-&gt;generateRefSect1($doc, &#039;description&#039;);

        $methodSynopsis = $this-&gt;getMethodSynopsisElement($funcMap, $aliasMap, $doc);
        if (!$methodSynopsis) {
            return null;
        }
        $descriptionRefSec-&gt;appendChild($methodSynopsis);
        $descriptionRefSec-&gt;appendChild(new DOMText(&quot;\n  &quot;));
        $undocumentedEntity = $doc-&gt;createEntityReference(&#039;warn.undocumented.func&#039;);
        $descriptionRefSec-&gt;appendChild($undocumentedEntity);
        $descriptionRefSec-&gt;appendChild(new DOMText(&quot;\n  &quot;));
        $returnDescriptionPara = $doc-&gt;createElement(&#039;para&#039;);
        $returnDescriptionPara-&gt;appendChild(new DOMText(&quot;\n   Description.\n  &quot;));
        $descriptionRefSec-&gt;appendChild($returnDescriptionPara);

        $descriptionRefSec-&gt;appendChild(new DOMText(&quot;\n &quot;));
        $refentry-&gt;append($descriptionRefSec, $REFSEC1_SEPERATOR);

        /* Creation of &lt;refsect1 role=&quot;parameters&quot;&gt; */
        $parametersRefSec = $this-&gt;getParameterSection($doc);
        $refentry-&gt;append($parametersRefSec, $REFSEC1_SEPERATOR);

        /* Creation of &lt;refsect1 role=&quot;returnvalues&quot;&gt; */
        if (!$this-&gt;name-&gt;isConstructor() &amp;&amp; !$this-&gt;name-&gt;isDestructor()) {
            $returnRefSec = $this-&gt;getReturnValueSection($doc);
            $refentry-&gt;append($returnRefSec, $REFSEC1_SEPERATOR);
        }

        /* Creation of &lt;refsect1 role=&quot;errors&quot;&gt; */
        $errorsRefSec = $this-&gt;generateRefSect1($doc, &#039;errors&#039;);
        $errorsDescriptionParaConstantTag = $doc-&gt;createElement(&#039;constant&#039;);
        $errorsDescriptionParaConstantTag-&gt;append(&#039;E_*&#039;);
        $errorsDescriptionParaExceptionTag = $doc-&gt;createElement(&#039;exceptionname&#039;);
        $errorsDescriptionParaExceptionTag-&gt;append(&#039;Exception&#039;);
        $errorsDescriptionPara = $doc-&gt;createElement(&#039;para&#039;);
        $errorsDescriptionPara-&gt;append(
            &quot;\n   When does this function issue &quot;,
            $errorsDescriptionParaConstantTag,
            &quot; level errors,\n   and/or throw &quot;,
            $errorsDescriptionParaExceptionTag,
            &quot;s.\n  &quot;
        );
        $errorsRefSec-&gt;appendChild($errorsDescriptionPara);
        $errorsRefSec-&gt;appendChild(new DOMText(&quot;\n &quot;));

        $refentry-&gt;append($errorsRefSec, $REFSEC1_SEPERATOR);

        /* Creation of &lt;refsect1 role=&quot;changelog&quot;&gt; */
        $changelogRefSec = $this-&gt;getChangelogSection($doc);
        $refentry-&gt;append($changelogRefSec, $REFSEC1_SEPERATOR);

        $exampleRefSec = $this-&gt;getExampleSection($doc, $id);
        $refentry-&gt;append($exampleRefSec, $REFSEC1_SEPERATOR);

        /* Creation of &lt;refsect1 role=&quot;notes&quot;&gt; */
        $notesRefSec = $this-&gt;generateRefSect1($doc, &#039;notes&#039;);

        $noteTagSimara = $doc-&gt;createElement(&#039;simpara&#039;);
        $noteTagSimara-&gt;append(
            &quot;\n    Any notes that don&#039;t fit anywhere else should go here.\n   &quot;
        );
        $noteTag = $doc-&gt;createElement(&#039;note&#039;);
        $noteTag-&gt;append(&quot;\n   &quot;, $noteTagSimara, &quot;\n  &quot;);
        $notesRefSec-&gt;append($noteTag, &quot;\n &quot;);

        $refentry-&gt;append($notesRefSec, $REFSEC1_SEPERATOR);

        /* Creation of &lt;refsect1 role=&quot;seealso&quot;&gt; */
        $seeAlsoRefSec = $this-&gt;generateRefSect1($doc, &#039;seealso&#039;);

        $seeAlsoMemberClassMethod = $doc-&gt;createElement(&#039;member&#039;);
        $seeAlsoMemberClassMethodTag = $doc-&gt;createElement(&#039;methodname&#039;);
        $seeAlsoMemberClassMethodTag-&gt;appendChild(new DOMText(&quot;ClassName::otherMethodName&quot;));
        $seeAlsoMemberClassMethod-&gt;appendChild($seeAlsoMemberClassMethodTag);

        $seeAlsoMemberFunction = $doc-&gt;createElement(&#039;member&#039;);
        $seeAlsoMemberFunctionTag = $doc-&gt;createElement(&#039;function&#039;);
        $seeAlsoMemberFunctionTag-&gt;appendChild(new DOMText(&quot;some_function&quot;));
        $seeAlsoMemberFunction-&gt;appendChild($seeAlsoMemberFunctionTag);

        $seeAlsoMemberLink = $doc-&gt;createElement(&#039;member&#039;);
        $seeAlsoMemberLinkTag = $doc-&gt;createElement(&#039;link&#039;);
        $seeAlsoMemberLinkTag-&gt;setAttribute(&#039;linkend&#039;, &#039;some.id.chunk.to.link&#039;);
        $seeAlsoMemberLinkTag-&gt;appendChild(new DOMText(&#039;something appendix&#039;));
        $seeAlsoMemberLink-&gt;appendChild($seeAlsoMemberLinkTag);

        $seeAlsoList = $doc-&gt;createElement(&#039;simplelist&#039;);
        $seeAlsoList-&gt;append(
            &quot;\n   &quot;,
            $seeAlsoMemberClassMethod,
            &quot;\n   &quot;,
            $seeAlsoMemberFunction,
            &quot;\n   &quot;,
            $seeAlsoMemberLink,
            &quot;\n  &quot;
        );

        $seeAlsoRefSec-&gt;appendChild($seeAlsoList);
        $seeAlsoRefSec-&gt;appendChild(new DOMText(&quot;\n &quot;));

        $refentry-&gt;appendChild($seeAlsoRefSec);

        $refentry-&gt;appendChild(new DOMText(&quot;\n\n&quot;));

        $doc-&gt;appendChild(new DOMComment(
            &lt;&lt;&lt;ENDCOMMENT
 Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:&quot;~/.phpdoc/manual.ced&quot;
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1

ENDCOMMENT
        ));
        return $doc-&gt;saveXML();
    }

    private function getParameterSection(DOMDocument $doc): DOMElement {
        $parametersRefSec = $this-&gt;generateRefSect1($doc, &#039;parameters&#039;);
        if (empty($this-&gt;args)) {
            $noParamEntity = $doc-&gt;createEntityReference(&#039;no.function.parameters&#039;);
            $parametersRefSec-&gt;appendChild($noParamEntity);
            return $parametersRefSec;
        } else {
            $parametersPara = $doc-&gt;createElement(&#039;para&#039;);
            $parametersRefSec-&gt;appendChild($parametersPara);

            $parametersPara-&gt;appendChild(new DOMText(&quot;\n   &quot;));
            $parametersList = $doc-&gt;createElement(&#039;variablelist&#039;);
            $parametersPara-&gt;appendChild($parametersList);

            /*
            &lt;varlistentry&gt;
             &lt;term&gt;&lt;parameter&gt;name&lt;/parameter&gt;&lt;/term&gt;
             &lt;listitem&gt;
              &lt;para&gt;
               Description.
              &lt;/para&gt;
             &lt;/listitem&gt;
            &lt;/varlistentry&gt;
            */
            foreach ($this-&gt;args as $arg) {
                $parameter = $doc-&gt;createElement(&#039;parameter&#039;, $arg-&gt;name);
                $parameterTerm = $doc-&gt;createElement(&#039;term&#039;);
                $parameterTerm-&gt;appendChild($parameter);

                $listItemPara = $doc-&gt;createElement(&#039;para&#039;);
                $listItemPara-&gt;append(
                    &quot;\n       &quot;,
                    &quot;Description.&quot;,
                    &quot;\n      &quot;,
                );

                $parameterEntryListItem = $doc-&gt;createElement(&#039;listitem&#039;);
                $parameterEntryListItem-&gt;append(
                    &quot;\n      &quot;,
                    $listItemPara,
                    &quot;\n     &quot;,
                );

                $parameterEntry = $doc-&gt;createElement(&#039;varlistentry&#039;);
                $parameterEntry-&gt;append(
                    &quot;\n     &quot;,
                    $parameterTerm,
                    &quot;\n     &quot;,
                    $parameterEntryListItem,
                    &quot;\n    &quot;,
                );

                $parametersList-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                $parametersList-&gt;appendChild($parameterEntry);
            }
            $parametersList-&gt;appendChild(new DOMText(&quot;\n   &quot;));
        }
        $parametersPara-&gt;appendChild(new DOMText(&quot;\n  &quot;));
        $parametersRefSec-&gt;appendChild(new DOMText(&quot;\n &quot;));
        return $parametersRefSec;
    }

    private function getReturnValueSection(DOMDocument $doc): DOMElement {
        $returnRefSec = $this-&gt;generateRefSect1($doc, &#039;returnvalues&#039;);

        $returnDescriptionPara = $doc-&gt;createElement(&#039;para&#039;);
        $returnDescriptionPara-&gt;appendChild(new DOMText(&quot;\n   &quot;));

        $returnType = $this-&gt;return-&gt;getMethodSynopsisType();
        if ($returnType === null) {
            $returnDescriptionPara-&gt;appendChild(new DOMText(&quot;Description.&quot;));
        } else if (count($returnType-&gt;types) === 1) {
            $type = $returnType-&gt;types[0];
            $name = $type-&gt;name;

            switch ($name) {
                case &#039;void&#039;:
                    $descriptionNode = $doc-&gt;createEntityReference(&#039;return.void&#039;);
                    break;
                case &#039;true&#039;:
                    $descriptionNode = $doc-&gt;createEntityReference(&#039;return.true.always&#039;);
                    break;
                case &#039;bool&#039;:
                    $descriptionNode = $doc-&gt;createEntityReference(&#039;return.success&#039;);
                    break;
                default:
                    $descriptionNode = new DOMText(&quot;Description.&quot;);
                    break;
            }
            $returnDescriptionPara-&gt;appendChild($descriptionNode);
        } else {
            $returnDescriptionPara-&gt;appendChild(new DOMText(&quot;Description.&quot;));
        }
        $returnDescriptionPara-&gt;appendChild(new DOMText(&quot;\n  &quot;));
        $returnRefSec-&gt;appendChild($returnDescriptionPara);
        $returnRefSec-&gt;appendChild(new DOMText(&quot;\n &quot;));
        return $returnRefSec;
    }

    /**
     * @param array&lt;DOMNode&gt; $headers [count($headers) === $columns]
     * @param array&lt;array&lt;DOMNode&gt;&gt; $rows [count($rows[$i]) === $columns]
     */
    private function generateDocbookInformalTable(
        DOMDocument $doc,
        int $indent,
        int $columns,
        array $headers,
        array $rows
    ): DOMElement {
        $strIndent = str_repeat(&#039; &#039;, $indent);

        $headerRow = $doc-&gt;createElement(&#039;row&#039;);
        foreach ($headers as $header) {
            $headerEntry = $doc-&gt;createElement(&#039;entry&#039;);
            $headerEntry-&gt;appendChild($header);

            $headerRow-&gt;append(&quot;\n$strIndent    &quot;, $headerEntry);
        }
        $headerRow-&gt;append(&quot;\n$strIndent   &quot;);

        $thead = $doc-&gt;createElement(&#039;thead&#039;);
        $thead-&gt;append(
            &quot;\n$strIndent   &quot;,
            $headerRow,
            &quot;\n$strIndent  &quot;,
        );

        $tbody = $doc-&gt;createElement(&#039;tbody&#039;);
        foreach ($rows as $row) {
            $bodyRow = $doc-&gt;createElement(&#039;row&#039;);
            foreach ($row as $cell) {
                $entry = $doc-&gt;createElement(&#039;entry&#039;);
                $entry-&gt;appendChild($cell);

                $bodyRow-&gt;appendChild(new DOMText(&quot;\n$strIndent    &quot;));
                $bodyRow-&gt;appendChild($entry);
            }
            $bodyRow-&gt;appendChild(new DOMText(&quot;\n$strIndent   &quot;));

            $tbody-&gt;append(
                &quot;\n$strIndent   &quot;,
                $bodyRow,
                &quot;\n$strIndent  &quot;,
            );
        }

        $tgroup = $doc-&gt;createElement(&#039;tgroup&#039;);
        $tgroup-&gt;setAttribute(&#039;cols&#039;, (string) $columns);
        $tgroup-&gt;append(
            &quot;\n$strIndent  &quot;,
            $thead,
            &quot;\n$strIndent  &quot;,
            $tbody,
            &quot;\n$strIndent &quot;,
        );

        $table = $doc-&gt;createElement(&#039;informaltable&#039;);
        $table-&gt;append(
            &quot;\n$strIndent &quot;,
            $tgroup,
            &quot;\n$strIndent&quot;,
        );

        return $table;
    }

    private function getChangelogSection(DOMDocument $doc): DOMElement {
        $refSec = $this-&gt;generateRefSect1($doc, &#039;changelog&#039;);
        $headers = [
            $doc-&gt;createEntityReference(&#039;Version&#039;),
            $doc-&gt;createEntityReference(&#039;Description&#039;),
        ];
        $rows = [[
            new DOMText(&#039;8.X.0&#039;),
            new DOMText(&quot;\n       Description\n      &quot;),
        ]];
        $table = $this-&gt;generateDocbookInformalTable(
            $doc,
            /* indent: */ 2,
            /* columns: */ 2,
            /* headers: */ $headers,
            /* rows: */ $rows
        );
        $refSec-&gt;appendChild($table);

        $refSec-&gt;appendChild(new DOMText(&quot;\n &quot;));
        return $refSec;
    }

    private function getExampleSection(DOMDocument $doc, string $id): DOMElement {
        $refSec = $this-&gt;generateRefSect1($doc, &#039;examples&#039;);

        $example = $doc-&gt;createElement(&#039;example&#039;);
        $fnName = $this-&gt;name-&gt;__toString();
        $example-&gt;setAttribute(&#039;xml:id&#039;, $id . &#039;.example.basic&#039;);

        $title = $doc-&gt;createElement(&#039;title&#039;);
        $fn = $doc-&gt;createElement($this-&gt;isMethod() ? &#039;methodname&#039; : &#039;function&#039;);
        $fn-&gt;append($fnName);
        $title-&gt;append($fn, &#039; example&#039;);

        $example-&gt;append(&quot;\n   &quot;, $title);

        $para = $doc-&gt;createElement(&#039;para&#039;);
        $para-&gt;append(&quot;\n    &quot;, &quot;Description.&quot;, &quot;\n   &quot;);
        $example-&gt;append(&quot;\n   &quot;, $para);

        $prog = $doc-&gt;createElement(&#039;programlisting&#039;);
        $prog-&gt;setAttribute(&#039;role&#039;, &#039;php&#039;);
        $code = new DOMCdataSection(
            &lt;&lt;&lt;CODE_EXAMPLE

&lt;?php
echo &quot;Code example&quot;;
?&gt;

CODE_EXAMPLE
        );
        $prog-&gt;append(&quot;\n&quot;);
        $prog-&gt;appendChild($code);
        $prog-&gt;append(&quot;\n   &quot;);

        $example-&gt;append(&quot;\n   &quot;, $prog);
        $example-&gt;append(&quot;\n   &quot;, $doc-&gt;createEntityReference(&#039;example.outputs&#039;));

        $output = new DOMCdataSection(
            &lt;&lt;&lt;OUPUT_EXAMPLE

Code example

OUPUT_EXAMPLE
        );
        $screen = $doc-&gt;createElement(&#039;screen&#039;);
        $screen-&gt;append(&quot;\n&quot;);
        $screen-&gt;appendChild($output);
        $screen-&gt;append(&quot;\n   &quot;);

        $example-&gt;append(
            &quot;\n   &quot;,
            $screen,
            &quot;\n  &quot;,
        );

        $refSec-&gt;append(
            $example,
            &quot;\n &quot;,
        );
        return $refSec;
    }

    /**
     * @param array&lt;string, FuncInfo&gt; $funcMap
     * @param array&lt;string, FuncInfo&gt; $aliasMap
     * @throws Exception
     */
    public function getMethodSynopsisElement(array $funcMap, array $aliasMap, DOMDocument $doc): ?DOMElement {
        if ($this-&gt;hasParamWithUnknownDefaultValue()) {
            return null;
        }

        if ($this-&gt;name-&gt;isConstructor()) {
            $synopsisType = &quot;constructorsynopsis&quot;;
        } elseif ($this-&gt;name-&gt;isDestructor()) {
            $synopsisType = &quot;destructorsynopsis&quot;;
        } else {
            $synopsisType = &quot;methodsynopsis&quot;;
        }

        $methodSynopsis = $doc-&gt;createElement($synopsisType);

        if ($this-&gt;isMethod()) {
            assert($this-&gt;name instanceof MethodName);
            $role = $doc-&gt;createAttribute(&quot;role&quot;);
            $role-&gt;value = addslashes($this-&gt;name-&gt;className-&gt;__toString());
            $methodSynopsis-&gt;appendChild($role);
        }

        $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));

        foreach ($this-&gt;getModifierNames() as $modifierString) {
            $modifierElement = $doc-&gt;createElement(&#039;modifier&#039;, $modifierString);
            $methodSynopsis-&gt;appendChild($modifierElement);
            $methodSynopsis-&gt;appendChild(new DOMText(&quot; &quot;));
        }

        $returnType = $this-&gt;return-&gt;getMethodSynopsisType();
        if ($returnType) {
            $methodSynopsis-&gt;appendChild($returnType-&gt;getTypeForDoc($doc));
        }

        $methodname = $doc-&gt;createElement(&#039;methodname&#039;, $this-&gt;name-&gt;__toString());
        $methodSynopsis-&gt;appendChild($methodname);

        if (empty($this-&gt;args)) {
            $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));
            $void = $doc-&gt;createElement(&#039;void&#039;);
            $methodSynopsis-&gt;appendChild($void);
        } else {
            foreach ($this-&gt;args as $arg) {
                $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));
                $methodparam = $doc-&gt;createElement(&#039;methodparam&#039;);
                if ($arg-&gt;defaultValue !== null) {
                    $methodparam-&gt;setAttribute(&quot;choice&quot;, &quot;opt&quot;);
                }
                if ($arg-&gt;isVariadic) {
                    $methodparam-&gt;setAttribute(&quot;rep&quot;, &quot;repeat&quot;);
                }

                $methodSynopsis-&gt;appendChild($methodparam);
                foreach ($arg-&gt;attributes as $attribute) {
                    $attribute = $doc-&gt;createElement(&quot;modifier&quot;, &quot;#[\\&quot; . $attribute-&gt;class . &quot;]&quot;);
                    $attribute-&gt;setAttribute(&quot;role&quot;, &quot;attribute&quot;);

                    $methodparam-&gt;appendChild($attribute);
                }

                $methodparam-&gt;appendChild($arg-&gt;getMethodSynopsisType()-&gt;getTypeForDoc($doc));

                $parameter = $doc-&gt;createElement(&#039;parameter&#039;, $arg-&gt;name);
                if ($arg-&gt;sendBy !== ArgInfo::SEND_BY_VAL) {
                    $parameter-&gt;setAttribute(&quot;role&quot;, &quot;reference&quot;);
                }

                $methodparam-&gt;appendChild($parameter);
                $defaultValue = $arg-&gt;getDefaultValueAsMethodSynopsisString();
                if ($defaultValue !== null) {
                    $initializer = $doc-&gt;createElement(&#039;initializer&#039;);
                    if (preg_match(&#039;/^[a-zA-Z_][a-zA-Z_0-9]*$/&#039;, $defaultValue)) {
                        $constant = $doc-&gt;createElement(&#039;constant&#039;, $defaultValue);
                        $initializer-&gt;appendChild($constant);
                    } else {
                        $initializer-&gt;nodeValue = $defaultValue;
                    }
                    $methodparam-&gt;appendChild($initializer);
                }
            }
        }
        $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n  &quot;));

        return $methodSynopsis;
    }

    public function __clone()
    {
        foreach ($this-&gt;args as $key =&gt; $argInfo) {
            $this-&gt;args[$key] = clone $argInfo;
        }
        $this-&gt;return = clone $this-&gt;return;
        foreach ($this-&gt;attributes as $key =&gt; $attribute) {
            $this-&gt;attributes[$key] = clone $attribute;
        }
        foreach ($this-&gt;framelessFunctionInfos as $key =&gt; $framelessFunctionInfo) {
            $this-&gt;framelessFunctionInfos[$key] = clone $framelessFunctionInfo;
        }
        if ($this-&gt;exposedDocComment) {
            $this-&gt;exposedDocComment = clone $this-&gt;exposedDocComment;
        }
    }
}

class EvaluatedValue
{
    /** @var mixed */
    public $value;
    public SimpleType $type;
    public Expr $expr;
    public bool $isUnknownConstValue;
    /** @var ConstInfo[] */
    public array $originatingConsts;

    /**
     * @param array&lt;string, ConstInfo&gt; $allConstInfos
     */
    public static function createFromExpression(Expr $expr, ?SimpleType $constType, ?string $cConstName, array $allConstInfos): EvaluatedValue
    {
        // This visitor replaces the PHP constants by C constants. It allows direct expansion of the compiled constants, e.g. later in the pretty printer.
        $visitor = new class($allConstInfos) extends PhpParser\NodeVisitorAbstract
        {
            /** @var iterable&lt;ConstInfo&gt; */
            public array $visitedConstants = [];
            /** @var array&lt;string, ConstInfo&gt; */
            public array $allConstInfos;

            /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
            public function __construct(array $allConstInfos)
            {
                $this-&gt;allConstInfos = $allConstInfos;
            }

            /** @return Node|null */
            public function enterNode(Node $expr)
            {
                if (!$expr instanceof Expr\ConstFetch &amp;&amp; !$expr instanceof Expr\ClassConstFetch) {
                    return null;
                }

                if ($expr instanceof Expr\ClassConstFetch) {
                    $originatingConstName = new ClassConstName($expr-&gt;class, $expr-&gt;name-&gt;toString());
                } else {
                    $originatingConstName = new ConstName($expr-&gt;name-&gt;getAttribute(&#039;namespacedName&#039;), $expr-&gt;name-&gt;toString());
                }

                if ($originatingConstName-&gt;isUnknown()) {
                    return null;
                }

                $const = $this-&gt;allConstInfos[$originatingConstName-&gt;__toString()] ?? null;
                if ($const !== null) {
                    $this-&gt;visitedConstants[] = $const;
                    return $const-&gt;getValue($this-&gt;allConstInfos)-&gt;expr;
                }
            }
        };

        $nodeTraverser = new PhpParser\NodeTraverser;
        $nodeTraverser-&gt;addVisitor($visitor);
        $expr = $nodeTraverser-&gt;traverse([$expr])[0];

        $isUnknownConstValue = false;

        $evaluator = new ConstExprEvaluator(
            static function (Expr $expr) use ($allConstInfos, &amp;$isUnknownConstValue) {
                // $expr is a ConstFetch with a name of a C macro here
                if (!$expr instanceof Expr\ConstFetch) {
                    throw new Exception($this-&gt;getVariableTypeName() . &quot; &quot; . $this-&gt;name-&gt;__toString() . &quot; has an unsupported value&quot;);
                }

                $constName = $expr-&gt;name-&gt;__toString();
                if (strtolower($constName) === &quot;unknown&quot;) {
                    $isUnknownConstValue = true;
                    return null;
                }

                foreach ($allConstInfos as $const) {
                    if ($constName != $const-&gt;cValue) {
                        continue;
                    }

                    $constType = ($const-&gt;phpDocType ?? $const-&gt;type)-&gt;tryToSimpleType();
                    if ($constType) {
                        if ($constType-&gt;isBool()) {
                            return true;
                        } elseif ($constType-&gt;isInt()) {
                            return 1;
                        } elseif ($constType-&gt;isFloat()) {
                            return M_PI;
                        } elseif ($constType-&gt;isString()) {
                            return $const-&gt;name;
                        } elseif ($constType-&gt;isArray()) {
                            return [];
                        }
                    }

                    return null;
                }

                throw new Exception(&quot;Constant &quot; . $constName . &quot; cannot be found&quot;);
            }
        );

        $result = $evaluator-&gt;evaluateDirectly($expr);

        return new EvaluatedValue(
            $result, // note: we are generally not interested in the actual value of $result, unless it&#039;s a bare value, without constants
            $constType ?? SimpleType::fromValue($result),
            $cConstName === null ? $expr : new Expr\ConstFetch(new Node\Name($cConstName)),
            $visitor-&gt;visitedConstants,
            $isUnknownConstValue
        );
    }

    public static function null(): EvaluatedValue
    {
        return new self(null, SimpleType::null(), new Expr\ConstFetch(new Node\Name(&#039;null&#039;)), [], false);
    }

    /**
     * @param mixed $value
     * @param ConstInfo[] $originatingConsts
     */
    private function __construct($value, SimpleType $type, Expr $expr, array $originatingConsts, bool $isUnknownConstValue)
    {
        $this-&gt;value = $value;
        $this-&gt;type = $type;
        $this-&gt;expr = $expr;
        $this-&gt;originatingConsts = $originatingConsts;
        $this-&gt;isUnknownConstValue = $isUnknownConstValue;
    }

    public function initializeZval(string $zvalName): string
    {
        $cExpr = $this-&gt;getCExpr();

        $code = &quot;\tzval $zvalName;\n&quot;;

        if ($this-&gt;type-&gt;isNull()) {
            $code .= &quot;\tZVAL_NULL(&amp;$zvalName);\n&quot;;
        } elseif ($this-&gt;type-&gt;isBool()) {
            if ($cExpr == &#039;true&#039;) {
                $code .= &quot;\tZVAL_TRUE(&amp;$zvalName);\n&quot;;
            } elseif ($cExpr == &#039;false&#039;) {
                $code .= &quot;\tZVAL_FALSE(&amp;$zvalName);\n&quot;;
            } else {
                $code .= &quot;\tZVAL_BOOL(&amp;$zvalName, $cExpr);\n&quot;;
            }
        } elseif ($this-&gt;type-&gt;isInt()) {
            $code .= &quot;\tZVAL_LONG(&amp;$zvalName, $cExpr);\n&quot;;
        } elseif ($this-&gt;type-&gt;isFloat()) {
            $code .= &quot;\tZVAL_DOUBLE(&amp;$zvalName, $cExpr);\n&quot;;
        } elseif ($this-&gt;type-&gt;isString()) {
            if ($cExpr === &#039;&quot;&quot;&#039;) {
                $code .= &quot;\tZVAL_EMPTY_STRING(&amp;$zvalName);\n&quot;;
            } else {
                $code .= &quot;\tzend_string *{$zvalName}_str = zend_string_init($cExpr, strlen($cExpr), 1);\n&quot;;
                $code .= &quot;\tZVAL_STR(&amp;$zvalName, {$zvalName}_str);\n&quot;;
            }
        } elseif ($this-&gt;type-&gt;isArray()) {
            if ($cExpr == &#039;[]&#039;) {
                $code .= &quot;\tZVAL_EMPTY_ARRAY(&amp;$zvalName);\n&quot;;
            } else {
                throw new Exception(&quot;Unimplemented default value&quot;);
            }
        } else {
            throw new Exception(&quot;Invalid default value: &quot; . print_r($this-&gt;value, true) . &quot;, type: &quot; . print_r($this-&gt;type, true));
        }

        return $code;
    }

    public function getCExpr(): ?string
    {
        // $this-&gt;expr has all its PHP constants replaced by C constants
        $prettyPrinter = new Standard;
        $expr = $prettyPrinter-&gt;prettyPrintExpr($this-&gt;expr);
        // PHP single-quote to C double-quote string
        if ($this-&gt;type-&gt;isString()) {
            $expr = preg_replace(&quot;/(^&#039;|&#039;$)/&quot;, &#039;&quot;&#039;, $expr);
        }
        return $expr[0] == &#039;&quot;&#039; ? $expr : preg_replace(&#039;(\bnull\b)&#039;, &#039;NULL&#039;, str_replace(&#039;\\&#039;, &#039;&#039;, $expr));
    }
}

abstract class VariableLike
{
    public int $flags;
    public ?Type $type;
    public ?Type $phpDocType;
    public ?string $link;
    public ?int $phpVersionIdMinimumCompatibility;
    /** @var AttributeInfo[] */
    public array $attributes;
    public ?ExposedDocComment $exposedDocComment;

    /**
     * @var AttributeInfo[] $attributes
     */
    public function __construct(
        int $flags,
        ?Type $type,
        ?Type $phpDocType,
        ?string $link,
        ?int $phpVersionIdMinimumCompatibility,
        array $attributes,
        ?ExposedDocComment $exposedDocComment
    ) {
        $this-&gt;flags = $flags;
        $this-&gt;type = $type;
        $this-&gt;phpDocType = $phpDocType;
        $this-&gt;link = $link;
        $this-&gt;phpVersionIdMinimumCompatibility = $phpVersionIdMinimumCompatibility;
        $this-&gt;attributes = $attributes;
        $this-&gt;exposedDocComment = $exposedDocComment;
    }

    abstract protected function getVariableTypeCode(): string;

    abstract protected function getVariableTypeName(): string;

    abstract protected function getFieldSynopsisDefaultLinkend(): string;

    abstract protected function getFieldSynopsisName(): string;

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    abstract protected function getFieldSynopsisValueString(array $allConstInfos): ?string;

    abstract public function discardInfoForOldPhpVersions(?int $minimumPhpVersionIdCompatibility): void;

    protected function addTypeToFieldSynopsis(DOMDocument $doc, DOMElement $fieldsynopsisElement): void
    {
        $type = $this-&gt;phpDocType ?? $this-&gt;type;

        if ($type) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($type-&gt;getTypeForDoc($doc));
        }
    }

    /**
     * @return array&lt;int, string[]&gt;
     */
    protected function getFlagsByPhpVersion(): array
    {
        $flags = &quot;ZEND_ACC_PUBLIC&quot;;
        if ($this-&gt;flags &amp; Modifiers::PROTECTED) {
            $flags = &quot;ZEND_ACC_PROTECTED&quot;;
        } elseif ($this-&gt;flags &amp; Modifiers::PRIVATE) {
            $flags = &quot;ZEND_ACC_PRIVATE&quot;;
        }

        return [
            PHP_70_VERSION_ID =&gt; [$flags],
            PHP_80_VERSION_ID =&gt; [$flags],
            PHP_81_VERSION_ID =&gt; [$flags],
            PHP_82_VERSION_ID =&gt; [$flags],
            PHP_83_VERSION_ID =&gt; [$flags],
            PHP_84_VERSION_ID =&gt; [$flags],
        ];
    }

    protected function getTypeCode(string $variableLikeName, string &amp;$code): string
    {
        $variableLikeType = $this-&gt;getVariableTypeName();

        $typeCode = &quot;&quot;;
        if ($this-&gt;type) {
            $arginfoType = $this-&gt;type-&gt;toArginfoType();
            if ($arginfoType-&gt;hasClassType()) {
                if (count($arginfoType-&gt;classTypes) &gt;= 2) {
                    foreach ($arginfoType-&gt;classTypes as $classType) {
                        $escapedClassName = $classType-&gt;toEscapedName();
                        $varEscapedClassName = $classType-&gt;toVarEscapedName();
                        $code .= &quot;\tzend_string *{$variableLikeType}_{$variableLikeName}_class_{$varEscapedClassName} = zend_string_init(\&quot;{$escapedClassName}\&quot;, sizeof(\&quot;{$escapedClassName}\&quot;) - 1, 1);\n&quot;;
                    }

                    $classTypeCount = count($arginfoType-&gt;classTypes);
                    $code .= &quot;\tzend_type_list *{$variableLikeType}_{$variableLikeName}_type_list = malloc(ZEND_TYPE_LIST_SIZE($classTypeCount));\n&quot;;
                    $code .= &quot;\t{$variableLikeType}_{$variableLikeName}_type_list-&gt;num_types = $classTypeCount;\n&quot;;

                    foreach ($arginfoType-&gt;classTypes as $k =&gt; $classType) {
                        $escapedClassName = $classType-&gt;toEscapedName();
                        $code .= &quot;\t{$variableLikeType}_{$variableLikeName}_type_list-&gt;types[$k] = (zend_type) ZEND_TYPE_INIT_CLASS({$variableLikeType}_{$variableLikeName}_class_{$escapedClassName}, 0, 0);\n&quot;;
                    }

                    $typeMaskCode = $this-&gt;type-&gt;toArginfoType()-&gt;toTypeMask();

                    if ($this-&gt;type-&gt;isIntersection) {
                        $code .= &quot;\tzend_type {$variableLikeType}_{$variableLikeName}_type = ZEND_TYPE_INIT_INTERSECTION({$variableLikeType}_{$variableLikeName}_type_list, $typeMaskCode);\n&quot;;
                    } else {
                        $code .= &quot;\tzend_type {$variableLikeType}_{$variableLikeName}_type = ZEND_TYPE_INIT_UNION({$variableLikeType}_{$variableLikeName}_type_list, $typeMaskCode);\n&quot;;
                    }
                    $typeCode = &quot;{$variableLikeType}_{$variableLikeName}_type&quot;;
                } else {
                    $escapedClassName = $arginfoType-&gt;classTypes[0]-&gt;toEscapedName();
                    $varEscapedClassName = $arginfoType-&gt;classTypes[0]-&gt;toVarEscapedName();
                    $code .= &quot;\tzend_string *{$variableLikeType}_{$variableLikeName}_class_{$varEscapedClassName} = zend_string_init(\&quot;{$escapedClassName}\&quot;, sizeof(\&quot;{$escapedClassName}\&quot;)-1, 1);\n&quot;;

                    $typeCode = &quot;(zend_type) ZEND_TYPE_INIT_CLASS({$variableLikeType}_{$variableLikeName}_class_{$varEscapedClassName}, 0, &quot; . $arginfoType-&gt;toTypeMask() . &quot;)&quot;;
                }
            } else {
                $typeCode = &quot;(zend_type) ZEND_TYPE_INIT_MASK(&quot; . $arginfoType-&gt;toTypeMask() . &quot;)&quot;;
            }
        } else {
            $typeCode = &quot;(zend_type) ZEND_TYPE_INIT_NONE(0)&quot;;
        }

        return $typeCode;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function getFieldSynopsisElement(DOMDocument $doc, array $allConstInfos): DOMElement
    {
        $fieldsynopsisElement = $doc-&gt;createElement(&quot;fieldsynopsis&quot;);

        $this-&gt;addModifiersToFieldSynopsis($doc, $fieldsynopsisElement);

        $this-&gt;addTypeToFieldSynopsis($doc, $fieldsynopsisElement);

        $varnameElement = $doc-&gt;createElement(&quot;varname&quot;, $this-&gt;getFieldSynopsisName());
        if ($this-&gt;link) {
            $varnameElement-&gt;setAttribute(&quot;linkend&quot;, $this-&gt;link);
        } else {
            $varnameElement-&gt;setAttribute(&quot;linkend&quot;, $this-&gt;getFieldSynopsisDefaultLinkend());
        }

        $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
        $fieldsynopsisElement-&gt;appendChild($varnameElement);

        $valueString = $this-&gt;getFieldSynopsisValueString($allConstInfos);
        if ($valueString) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $initializerElement = $doc-&gt;createElement(&quot;initializer&quot;,  $valueString);
            $fieldsynopsisElement-&gt;appendChild($initializerElement);
        }

        $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n    &quot;));

        return $fieldsynopsisElement;
    }

    protected function addModifiersToFieldSynopsis(DOMDocument $doc, DOMElement $fieldsynopsisElement): void
    {
        if ($this-&gt;flags &amp; Modifiers::PUBLIC) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;public&quot;));
        } elseif ($this-&gt;flags &amp; Modifiers::PROTECTED) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;protected&quot;));
        } elseif ($this-&gt;flags &amp; Modifiers::PRIVATE) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;private&quot;));
        }
    }

    /**
     * @param array&lt;int, string[]&gt; $flags
     * @return array&lt;int, string[]&gt;
     */
    protected function addFlagForVersionsAbove(array $flags, string $flag, int $minimumVersionId): array
    {
        $write = false;

        foreach ($flags as $version =&gt; $versionFlags) {
            if ($version === $minimumVersionId || $write === true) {
                $flags[$version][] = $flag;
                $write = true;
            }
        }

        return $flags;
    }
}

class ConstInfo extends VariableLike
{
    public ConstOrClassConstName $name;
    public Expr $value;
    public bool $isDeprecated;
    public ?string $valueString;
    public ?string $cond;
    public ?string $cValue;
    public bool $isUndocumentable;
    public bool $isFileCacheAllowed;

    /**
     * @var AttributeInfo[] $attributes
     */
    public function __construct(
        ConstOrClassConstName $name,
        int $flags,
        Expr $value,
        ?string $valueString,
        ?Type $type,
        ?Type $phpDocType,
        bool $isDeprecated,
        ?string $cond,
        ?string $cValue,
        bool $isUndocumentable,
        ?string $link,
        ?int $phpVersionIdMinimumCompatibility,
        array $attributes,
        ?ExposedDocComment $exposedDocComment,
        bool $isFileCacheAllowed
    ) {
        $this-&gt;name = $name;
        $this-&gt;value = $value;
        $this-&gt;valueString = $valueString;
        $this-&gt;isDeprecated = $isDeprecated;
        $this-&gt;cond = $cond;
        $this-&gt;cValue = $cValue;
        $this-&gt;isUndocumentable = $isUndocumentable;
        $this-&gt;isFileCacheAllowed = $isFileCacheAllowed;
        parent::__construct($flags, $type, $phpDocType, $link, $phpVersionIdMinimumCompatibility, $attributes, $exposedDocComment);
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function getValue(array $allConstInfos): EvaluatedValue
    {
        return EvaluatedValue::createFromExpression(
            $this-&gt;value,
            ($this-&gt;phpDocType ?? $this-&gt;type)-&gt;tryToSimpleType(),
            $this-&gt;cValue,
            $allConstInfos
        );
    }

    protected function getVariableTypeName(): string
    {
        return &quot;constant&quot;;
    }

    protected function getVariableTypeCode(): string
    {
        return &quot;const&quot;;
    }

    protected function getFieldSynopsisDefaultLinkend(): string
    {
        $className = str_replace([&quot;\\&quot;, &quot;_&quot;], [&quot;-&quot;, &quot;-&quot;], $this-&gt;name-&gt;class-&gt;toLowerString());

        return &quot;$className.constants.&quot; . strtolower(str_replace([&quot;__&quot;, &quot;_&quot;], [&quot;&quot;, &quot;-&quot;], $this-&gt;name-&gt;getDeclarationName()));
    }

    protected function getFieldSynopsisName(): string
    {
        return $this-&gt;name-&gt;__toString();
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    protected function getFieldSynopsisValueString(array $allConstInfos): ?string
    {
        $value = EvaluatedValue::createFromExpression($this-&gt;value, null, $this-&gt;cValue, $allConstInfos);
        if ($value-&gt;isUnknownConstValue) {
            return null;
        }

        if ($value-&gt;originatingConsts) {
            return implode(&quot;\n&quot;, array_map(function (ConstInfo $const) use ($allConstInfos) {
                return $const-&gt;getFieldSynopsisValueString($allConstInfos);
            }, $value-&gt;originatingConsts));
        }

        return $this-&gt;valueString;
    }

    public function getPredefinedConstantTerm(DOMDocument $doc, int $indentationLevel): DOMElement {
        $indentation = str_repeat(&quot; &quot;, $indentationLevel);

        $termElement = $doc-&gt;createElement(&quot;term&quot;);

        $constantElement = $doc-&gt;createElement(&quot;constant&quot;);
        $constantElement-&gt;textContent = $this-&gt;name-&gt;__toString();

        $typeElement = ($this-&gt;phpDocType ?? $this-&gt;type)-&gt;getTypeForDoc($doc);

        $termElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
        $termElement-&gt;appendChild($constantElement);
        $termElement-&gt;appendChild(new DOMText(&quot;\n$indentation (&quot;));
        $termElement-&gt;appendChild($typeElement);
        $termElement-&gt;appendChild(new DOMText(&quot;)\n$indentation&quot;));

        return $termElement;
    }

     public function getPredefinedConstantEntry(DOMDocument $doc, int $indentationLevel): DOMElement {
        $indentation = str_repeat(&quot; &quot;, $indentationLevel);

        $entryElement = $doc-&gt;createElement(&quot;entry&quot;);

        $constantElement = $doc-&gt;createElement(&quot;constant&quot;);
        $constantElement-&gt;textContent = $this-&gt;name-&gt;__toString();
        $typeElement = ($this-&gt;phpDocType ?? $this-&gt;type)-&gt;getTypeForDoc($doc);

        $entryElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
        $entryElement-&gt;appendChild($constantElement);
        $entryElement-&gt;appendChild(new DOMText(&quot;\n$indentation (&quot;));
        $entryElement-&gt;appendChild($typeElement);
        $entryElement-&gt;appendChild(new DOMText(&quot;)\n$indentation&quot;));

        return $entryElement;
    }

    public function discardInfoForOldPhpVersions(?int $phpVersionIdMinimumCompatibility): void {
        $this-&gt;type = null;
        $this-&gt;flags &amp;= ~Modifiers::FINAL;
        $this-&gt;isDeprecated = false;
        $this-&gt;attributes = [];
        $this-&gt;phpVersionIdMinimumCompatibility = $phpVersionIdMinimumCompatibility;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function getDeclaration(array $allConstInfos): string
    {
        $type = $this-&gt;phpDocType ?? $this-&gt;type;
        $simpleType = $type ? $type-&gt;tryToSimpleType() : null;
        if ($simpleType &amp;&amp; $simpleType-&gt;name === &quot;mixed&quot;) {
            $simpleType = null;
        }

        $value = EvaluatedValue::createFromExpression($this-&gt;value, $simpleType, $this-&gt;cValue, $allConstInfos);
        if ($value-&gt;isUnknownConstValue &amp;&amp; ($simpleType === null || !$simpleType-&gt;isBuiltin)) {
            throw new Exception(&quot;Constant &quot; . $this-&gt;name-&gt;__toString() . &quot; must have a built-in PHPDoc type as the type couldn&#039;t be inferred from its value&quot;);
        }

        // i.e. const NAME = UNKNOWN;, without the annotation
        if ($value-&gt;isUnknownConstValue &amp;&amp; $this-&gt;cValue === null &amp;&amp; $value-&gt;expr instanceof Expr\ConstFetch &amp;&amp; $value-&gt;expr-&gt;name-&gt;__toString() === &quot;UNKNOWN&quot;) {
            throw new Exception(&quot;Constant &quot; . $this-&gt;name-&gt;__toString() . &quot; must have a @cvalue annotation&quot;);
        }

        $code = &quot;&quot;;

        if ($this-&gt;cond) {
            $code .= &quot;#if {$this-&gt;cond}\n&quot;;
        }

        if ($this-&gt;name-&gt;isClassConst()) {
            $code .= $this-&gt;getClassConstDeclaration($value, $allConstInfos);
        } else {
            $code .= $this-&gt;getGlobalConstDeclaration($value, $allConstInfos);
        }
        $code .= $this-&gt;getValueAssertion($value);

        if ($this-&gt;cond) {
            $code .= &quot;#endif\n&quot;;
        }

        return $code;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    private function getGlobalConstDeclaration(EvaluatedValue $value, array $allConstInfos): string
    {
        $constName = str_replace(&#039;\\&#039;, &#039;\\\\&#039;, $this-&gt;name-&gt;__toString());
        $constValue = $value-&gt;value;
        $cExpr = $value-&gt;getCExpr();

        $flags = &quot;CONST_PERSISTENT&quot;;
        if (!$this-&gt;isFileCacheAllowed) {
            $flags .= &quot; | CONST_NO_FILE_CACHE&quot;;
        }
        if ($this-&gt;phpVersionIdMinimumCompatibility !== null &amp;&amp; $this-&gt;phpVersionIdMinimumCompatibility &lt; 80000) {
            $flags .= &quot; | CONST_CS&quot;;
        }

        if ($this-&gt;isDeprecated) {
            $flags .= &quot; | CONST_DEPRECATED&quot;;
        }
        if ($value-&gt;type-&gt;isNull()) {
            return &quot;\tREGISTER_NULL_CONSTANT(\&quot;$constName\&quot;, $flags);\n&quot;;
        }

        if ($value-&gt;type-&gt;isBool()) {
            return &quot;\tREGISTER_BOOL_CONSTANT(\&quot;$constName\&quot;, &quot; . ($cExpr ?: ($constValue ? &quot;true&quot; : &quot;false&quot;)) . &quot;, $flags);\n&quot;;
        }

        if ($value-&gt;type-&gt;isInt()) {
            return &quot;\tREGISTER_LONG_CONSTANT(\&quot;$constName\&quot;, &quot; . ($cExpr ?: (int) $constValue) . &quot;, $flags);\n&quot;;
        }

        if ($value-&gt;type-&gt;isFloat()) {
            return &quot;\tREGISTER_DOUBLE_CONSTANT(\&quot;$constName\&quot;, &quot; . ($cExpr ?: (float) $constValue) . &quot;, $flags);\n&quot;;
        }

        if ($value-&gt;type-&gt;isString()) {
            return &quot;\tREGISTER_STRING_CONSTANT(\&quot;$constName\&quot;, &quot; . ($cExpr ?: &#039;&quot;&#039; . addslashes($constValue) . &#039;&quot;&#039;) . &quot;, $flags);\n&quot;;
        }

        throw new Exception(&quot;Unimplemented constant type&quot;);
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    private function getClassConstDeclaration(EvaluatedValue $value, array $allConstInfos): string
    {
        $constName = $this-&gt;name-&gt;getDeclarationName();

        $zvalCode = $value-&gt;initializeZval(&quot;const_{$constName}_value&quot;, $allConstInfos);

        $code = &quot;\n&quot; . $zvalCode;

        $code .= &quot;\tzend_string *const_{$constName}_name = zend_string_init_interned(\&quot;$constName\&quot;, sizeof(\&quot;$constName\&quot;) - 1, 1);\n&quot;;
        $nameCode = &quot;const_{$constName}_name&quot;;

        if ($this-&gt;exposedDocComment) {
            $commentCode = &quot;const_{$constName}_comment&quot;;
            $escapedComment = $this-&gt;exposedDocComment-&gt;escape();
            $escapedCommentLength = $this-&gt;exposedDocComment-&gt;getLength();
            $code .= &quot;\tzend_string *$commentCode = zend_string_init_interned(\&quot;$escapedComment\&quot;, $escapedCommentLength, 1);\n&quot;;
        } else {
            $commentCode = &quot;NULL&quot;;
        }

        $php83MinimumCompatibility = $this-&gt;phpVersionIdMinimumCompatibility === null || $this-&gt;phpVersionIdMinimumCompatibility &gt;= PHP_83_VERSION_ID;

        if ($this-&gt;type &amp;&amp; !$php83MinimumCompatibility) {
            $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_83_VERSION_ID . &quot;)\n&quot;;
        }

        if ($this-&gt;type) {
            $typeCode = $this-&gt;getTypeCode($constName, $code);

            if (!empty($this-&gt;attributes)) {
                $template = &quot;\tzend_class_constant *const_&quot; . $this-&gt;name-&gt;getDeclarationName() . &quot; = &quot;;
            } else {
                $template = &quot;\t&quot;;
            }
            $template .= &quot;zend_declare_typed_class_constant(class_entry, $nameCode, &amp;const_{$constName}_value, %s, $commentCode, $typeCode);\n&quot;;

            $flagsCode = generateVersionDependentFlagCode(
                $template,
                $this-&gt;getFlagsByPhpVersion(),
                $this-&gt;phpVersionIdMinimumCompatibility
            );
            $code .= implode(&quot;&quot;, $flagsCode);
        }

        if ($this-&gt;type &amp;&amp; !$php83MinimumCompatibility) {
            $code .= &quot;#else\n&quot;;
        }

        if (!$this-&gt;type || !$php83MinimumCompatibility) {
            if (!empty($this-&gt;attributes)) {
                $template = &quot;\tzend_class_constant *const_&quot; . $this-&gt;name-&gt;getDeclarationName() . &quot; = &quot;;
            } else {
                $template = &quot;\t&quot;;
            }
            $template .= &quot;zend_declare_class_constant_ex(class_entry, $nameCode, &amp;const_{$constName}_value, %s, $commentCode);\n&quot;;
            $flagsCode = generateVersionDependentFlagCode(
                $template,
                $this-&gt;getFlagsByPhpVersion(),
                $this-&gt;phpVersionIdMinimumCompatibility
            );
            $code .= implode(&quot;&quot;, $flagsCode);
        }

        if ($this-&gt;type &amp;&amp; !$php83MinimumCompatibility) {
            $code .= &quot;#endif\n&quot;;
        }

        $code .= &quot;\tzend_string_release(const_{$constName}_name);\n&quot;;

        return $code;
    }

    private function getValueAssertion(EvaluatedValue $value): string
    {
        if ($value-&gt;isUnknownConstValue || $value-&gt;originatingConsts || $this-&gt;cValue === null) {
            return &quot;&quot;;
        }

        $cExpr = $value-&gt;getCExpr();
        $constValue = $value-&gt;value;

        if ($value-&gt;type-&gt;isNull()) {
            return &quot;\tZEND_ASSERT($cExpr == NULL);\n&quot;;
        }

        if ($value-&gt;type-&gt;isBool()) {
            $cValue = $constValue ? &quot;true&quot; : &quot;false&quot;;
            return &quot;\tZEND_ASSERT($cExpr == $cValue);\n&quot;;
        }

        if ($value-&gt;type-&gt;isInt()) {
            $cValue = (int) $constValue;
            return &quot;\tZEND_ASSERT($cExpr == $cValue);\n&quot;;
        }

        if ($value-&gt;type-&gt;isFloat()) {
            $cValue = (float) $constValue;
            return &quot;\tZEND_ASSERT($cExpr == $cValue);\n&quot;;
        }

        if ($value-&gt;type-&gt;isString()) {
            $cValue = &#039;&quot;&#039; . addslashes($constValue) . &#039;&quot;&#039;;
            return &quot;\tZEND_ASSERT(strcmp($cExpr, $cValue) == 0);\n&quot;;
        }

        throw new Exception(&quot;Unimplemented constant type&quot;);
    }

    /**
     * @return array&lt;int, string[]&gt;
     */
    protected function getFlagsByPhpVersion(): array
    {
        $flags = parent::getFlagsByPhpVersion();

        if ($this-&gt;isDeprecated) {
            $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_DEPRECATED&quot;, PHP_80_VERSION_ID);
        }

        foreach ($this-&gt;attributes as $attr) {
            if ($attr-&gt;class === &quot;Deprecated&quot;) {
                $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_DEPRECATED&quot;, PHP_80_VERSION_ID);
                break;
            }
        }

        if ($this-&gt;flags &amp; Modifiers::FINAL) {
            $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_FINAL&quot;, PHP_81_VERSION_ID);
        }

        return $flags;
    }

    protected function addModifiersToFieldSynopsis(DOMDocument $doc, DOMElement $fieldsynopsisElement): void
    {
        parent::addModifiersToFieldSynopsis($doc, $fieldsynopsisElement);

        if ($this-&gt;flags &amp; Modifiers::FINAL) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;final&quot;));
        }

        $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
        $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;const&quot;));
    }
}

class PropertyInfo extends VariableLike
{
    public int $classFlags;
    public PropertyName $name;
    public ?Expr $defaultValue;
    public ?string $defaultValueString;
    public bool $isDocReadonly;
    public bool $isVirtual;

    /**
     * @var AttributeInfo[] $attributes
     */
    public function __construct(
        PropertyName $name,
        int $classFlags,
        int $flags,
        ?Type $type,
        ?Type $phpDocType,
        ?Expr $defaultValue,
        ?string $defaultValueString,
        bool $isDocReadonly,
        bool $isVirtual,
        ?string $link,
        ?int $phpVersionIdMinimumCompatibility,
        array $attributes,
        ?ExposedDocComment $exposedDocComment
    ) {
        $this-&gt;name = $name;
        $this-&gt;classFlags = $classFlags;
        $this-&gt;defaultValue = $defaultValue;
        $this-&gt;defaultValueString = $defaultValueString;
        $this-&gt;isDocReadonly = $isDocReadonly;
        $this-&gt;isVirtual = $isVirtual;
        parent::__construct($flags, $type, $phpDocType, $link, $phpVersionIdMinimumCompatibility, $attributes, $exposedDocComment);
    }

    protected function getVariableTypeCode(): string
    {
        return &quot;property&quot;;
    }

    protected function getVariableTypeName(): string
    {
        return &quot;property&quot;;
    }

    protected function getFieldSynopsisDefaultLinkend(): string
    {
        $className = str_replace([&quot;\\&quot;, &quot;_&quot;], [&quot;-&quot;, &quot;-&quot;], $this-&gt;name-&gt;class-&gt;toLowerString());

        return &quot;$className.props.&quot; . strtolower(str_replace([&quot;__&quot;, &quot;_&quot;], [&quot;&quot;, &quot;-&quot;], $this-&gt;name-&gt;getDeclarationName()));
    }

    protected function getFieldSynopsisName(): string
    {
        return $this-&gt;name-&gt;getDeclarationName();
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    protected function getFieldSynopsisValueString(array $allConstInfos): ?string
    {
        return $this-&gt;defaultValueString;
    }

    public function discardInfoForOldPhpVersions(?int $phpVersionIdMinimumCompatibility): void {
        $this-&gt;type = null;
        $this-&gt;flags &amp;= ~Modifiers::READONLY;
        $this-&gt;attributes = [];
        $this-&gt;phpVersionIdMinimumCompatibility = $phpVersionIdMinimumCompatibility;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function getDeclaration(array $allConstInfos): string {
        $code = &quot;\n&quot;;

        $propertyName = $this-&gt;name-&gt;getDeclarationName();

        if ($this-&gt;defaultValue === null) {
            $defaultValue = EvaluatedValue::null();
        } else {
            $defaultValue = EvaluatedValue::createFromExpression($this-&gt;defaultValue, null, null, $allConstInfos);
            if ($defaultValue-&gt;isUnknownConstValue || ($defaultValue-&gt;originatingConsts &amp;&amp; $defaultValue-&gt;getCExpr() === null)) {
                echo &quot;Skipping code generation for property $this-&gt;name, because it has an unknown constant default value\n&quot;;
                return &quot;&quot;;
            }
        }

        $zvalName = &quot;property_{$propertyName}_default_value&quot;;
        if ($this-&gt;defaultValue === null &amp;&amp; $this-&gt;type !== null) {
            $code .= &quot;\tzval $zvalName;\n\tZVAL_UNDEF(&amp;$zvalName);\n&quot;;
        } else {
            $code .= $defaultValue-&gt;initializeZval($zvalName);
        }

        $code .= &quot;\tzend_string *property_{$propertyName}_name = zend_string_init(\&quot;$propertyName\&quot;, sizeof(\&quot;$propertyName\&quot;) - 1, 1);\n&quot;;
        $nameCode = &quot;property_{$propertyName}_name&quot;;

        if ($this-&gt;exposedDocComment) {
            $commentCode = &quot;property_{$propertyName}_comment&quot;;
            $escapedComment = $this-&gt;exposedDocComment-&gt;escape();
            $escapedCommentLength = $this-&gt;exposedDocComment-&gt;getLength();
            $code .= &quot;\tzend_string *$commentCode = zend_string_init_interned(\&quot;$escapedComment\&quot;, $escapedCommentLength, 1);\n&quot;;
        } else {
            $commentCode = &quot;NULL&quot;;
        }

        if (!empty($this-&gt;attributes)) {
            $template = &quot;\tzend_property_info *property_&quot; . $this-&gt;name-&gt;getDeclarationName() . &quot; = &quot;;
        } else {
            $template = &quot;\t&quot;;
        }

        if ($this-&gt;phpVersionIdMinimumCompatibility === null || $this-&gt;phpVersionIdMinimumCompatibility &gt;= PHP_80_VERSION_ID) {
            $typeCode = $this-&gt;getTypeCode($propertyName, $code);
            $template .= &quot;zend_declare_typed_property(class_entry, $nameCode, &amp;$zvalName, %s, $commentCode, $typeCode);\n&quot;;
        } else {
            $template .= &quot;zend_declare_property_ex(class_entry, $nameCode, &amp;$zvalName, %s, $commentCode);\n&quot;;
        }

        $flagsCode = generateVersionDependentFlagCode(
            $template,
            $this-&gt;getFlagsByPhpVersion(),
            $this-&gt;phpVersionIdMinimumCompatibility
        );
        $code .= implode(&quot;&quot;, $flagsCode);

        $code .= &quot;\tzend_string_release(property_{$propertyName}_name);\n&quot;;

        return $code;
    }

    /**
     * @return array&lt;int, string[]&gt;
     */
    protected function getFlagsByPhpVersion(): array
    {
        $flags = parent::getFlagsByPhpVersion();

        if ($this-&gt;flags &amp; Modifiers::STATIC) {
            $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_STATIC&quot;, PHP_70_VERSION_ID);
        }

        if ($this-&gt;flags &amp; Modifiers::READONLY) {
            $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_READONLY&quot;, PHP_81_VERSION_ID);
        } elseif ($this-&gt;classFlags &amp; Modifiers::READONLY) {
            $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_READONLY&quot;, PHP_82_VERSION_ID);
        }

        if ($this-&gt;isVirtual) {
            $flags = $this-&gt;addFlagForVersionsAbove($flags, &quot;ZEND_ACC_VIRTUAL&quot;, PHP_84_VERSION_ID);
        }

        return $flags;
    }

    protected function addModifiersToFieldSynopsis(DOMDocument $doc, DOMElement $fieldsynopsisElement): void
    {
        parent::addModifiersToFieldSynopsis($doc, $fieldsynopsisElement);

        if ($this-&gt;flags &amp; Modifiers::STATIC) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;static&quot;));
        }

        if ($this-&gt;flags &amp; Modifiers::READONLY || $this-&gt;isDocReadonly) {
            $fieldsynopsisElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
            $fieldsynopsisElement-&gt;appendChild($doc-&gt;createElement(&quot;modifier&quot;, &quot;readonly&quot;));
        }
    }

    public function __clone()
    {
        if ($this-&gt;type) {
            $this-&gt;type = clone $this-&gt;type;
        }
        foreach ($this-&gt;attributes as $key =&gt; $attribute) {
            $this-&gt;attributes[$key] = clone $attribute;
        }
        if ($this-&gt;exposedDocComment) {
            $this-&gt;exposedDocComment = clone $this-&gt;exposedDocComment;
        }
    }
}

class EnumCaseInfo {
    public string $name;
    public ?Expr $value;

    public function __construct(string $name, ?Expr $value) {
        $this-&gt;name = $name;
        $this-&gt;value = $value;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function getDeclaration(array $allConstInfos): string {
        $escapedName = addslashes($this-&gt;name);
        if ($this-&gt;value === null) {
            $code = &quot;\n\tzend_enum_add_case_cstr(class_entry, \&quot;$escapedName\&quot;, NULL);\n&quot;;
        } else {
            $value = EvaluatedValue::createFromExpression($this-&gt;value, null, null, $allConstInfos);

            $zvalName = &quot;enum_case_{$escapedName}_value&quot;;
            $code = &quot;\n&quot; . $value-&gt;initializeZval($zvalName);
            $code .= &quot;\tzend_enum_add_case_cstr(class_entry, \&quot;$escapedName\&quot;, &amp;$zvalName);\n&quot;;
        }

        return $code;
    }
}

class AttributeInfo {
    public string $class;
    /** @var \PhpParser\Node\Arg[] */
    public array $args;

    /** @param \PhpParser\Node\Arg[] $args */
    public function __construct(string $class, array $args) {
        $this-&gt;class = $class;
        $this-&gt;args = $args;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function generateCode(string $invocation, string $nameSuffix, array $allConstInfos, ?int $phpVersionIdMinimumCompatibility): string {
        $php82MinimumCompatibility = $phpVersionIdMinimumCompatibility === null || $phpVersionIdMinimumCompatibility &gt;= PHP_82_VERSION_ID;
        $php84MinimumCompatibility = $phpVersionIdMinimumCompatibility === null || $phpVersionIdMinimumCompatibility &gt;= PHP_84_VERSION_ID;
        /* see ZEND_KNOWN_STRINGS in Zend/strings.h */
        $knowns = [
            &quot;message&quot; =&gt; &quot;ZEND_STR_MESSAGE&quot;,
        ];
        if ($php82MinimumCompatibility) {
            $knowns[&quot;SensitiveParameter&quot;] = &quot;ZEND_STR_SENSITIVEPARAMETER&quot;;
        }
        if ($php84MinimumCompatibility) {
            $knowns[&quot;Deprecated&quot;] = &quot;ZEND_STR_DEPRECATED_CAPITALIZED&quot;;
            $knowns[&quot;since&quot;] = &quot;ZEND_STR_SINCE&quot;;
        }

        $code = &quot;\n&quot;;
        $escapedAttributeName = strtr($this-&gt;class, &#039;\\&#039;, &#039;_&#039;);
        if (isset($knowns[$escapedAttributeName])) {
            $code .= &quot;\t&quot; . ($this-&gt;args ? &quot;zend_attribute *attribute_{$escapedAttributeName}_$nameSuffix = &quot; : &quot;&quot;) . &quot;$invocation, ZSTR_KNOWN({$knowns[$escapedAttributeName]}), &quot; . count($this-&gt;args) . &quot;);\n&quot;;
        } else {
            $code .= &quot;\tzend_string *attribute_name_{$escapedAttributeName}_$nameSuffix = zend_string_init_interned(\&quot;&quot; . addcslashes($this-&gt;class, &quot;\\&quot;) . &quot;\&quot;, sizeof(\&quot;&quot; . addcslashes($this-&gt;class, &quot;\\&quot;) . &quot;\&quot;) - 1, 1);\n&quot;;
            $code .= &quot;\t&quot; . ($this-&gt;args ? &quot;zend_attribute *attribute_{$escapedAttributeName}_$nameSuffix = &quot; : &quot;&quot;) . &quot;$invocation, attribute_name_{$escapedAttributeName}_$nameSuffix, &quot; . count($this-&gt;args) . &quot;);\n&quot;;
            $code .= &quot;\tzend_string_release(attribute_name_{$escapedAttributeName}_$nameSuffix);\n&quot;;
        }
        foreach ($this-&gt;args as $i =&gt; $arg) {
            $value = EvaluatedValue::createFromExpression($arg-&gt;value, null, null, $allConstInfos);
            $zvalName = &quot;attribute_{$escapedAttributeName}_{$nameSuffix}_arg$i&quot;;
            $code .= $value-&gt;initializeZval($zvalName);
            $code .= &quot;\tZVAL_COPY_VALUE(&amp;attribute_{$escapedAttributeName}_{$nameSuffix}-&gt;args[$i].value, &amp;$zvalName);\n&quot;;
            if ($arg-&gt;name) {
                if (isset($knowns[$arg-&gt;name-&gt;name])) {
                    $code .= &quot;\tattribute_{$escapedAttributeName}_{$nameSuffix}-&gt;args[$i].name = ZSTR_KNOWN({$knowns[$arg-&gt;name-&gt;name]});\n&quot;;
                } else {
                    $code .= &quot;\tattribute_{$escapedAttributeName}_{$nameSuffix}-&gt;args[$i].name = zend_string_init_interned(\&quot;{$arg-&gt;name-&gt;name}\&quot;, sizeof(\&quot;{$arg-&gt;name-&gt;name}\&quot;) - 1, 1);\n&quot;;
                }
            }
        }
        return $code;
    }
}

class ClassInfo {
    public Name $name;
    public int $flags;
    public string $type;
    public ?string $alias;
    public ?SimpleType $enumBackingType;
    public bool $isDeprecated;
    public bool $isStrictProperties;
    /** @var AttributeInfo[] */
    public array $attributes;
    public ?ExposedDocComment $exposedDocComment;
    public bool $isNotSerializable;
    /** @var Name[] */
    public array $extends;
    /** @var Name[] */
    public array $implements;
    /** @var ConstInfo[] */
    public array $constInfos;
    /** @var PropertyInfo[] */
    public array $propertyInfos;
    /** @var FuncInfo[] */
    public array $funcInfos;
    /** @var EnumCaseInfo[] */
    public array $enumCaseInfos;
    public ?string $cond;
    public ?int $phpVersionIdMinimumCompatibility;
    public bool $isUndocumentable;

    /**
     * @param AttributeInfo[] $attributes
     * @param Name[] $extends
     * @param Name[] $implements
     * @param ConstInfo[] $constInfos
     * @param PropertyInfo[] $propertyInfos
     * @param FuncInfo[] $funcInfos
     * @param EnumCaseInfo[] $enumCaseInfos
     */
    public function __construct(
        Name $name,
        int $flags,
        string $type,
        ?string $alias,
        ?SimpleType $enumBackingType,
        bool $isDeprecated,
        bool $isStrictProperties,
        array $attributes,
        ?ExposedDocComment $exposedDocComment,
        bool $isNotSerializable,
        array $extends,
        array $implements,
        array $constInfos,
        array $propertyInfos,
        array $funcInfos,
        array $enumCaseInfos,
        ?string $cond,
        ?int $minimumPhpVersionIdCompatibility,
        bool $isUndocumentable
    ) {
        $this-&gt;name = $name;
        $this-&gt;flags = $flags;
        $this-&gt;type = $type;
        $this-&gt;alias = $alias;
        $this-&gt;enumBackingType = $enumBackingType;
        $this-&gt;isDeprecated = $isDeprecated;
        $this-&gt;isStrictProperties = $isStrictProperties;
        $this-&gt;attributes = $attributes;
        $this-&gt;exposedDocComment = $exposedDocComment;
        $this-&gt;isNotSerializable = $isNotSerializable;
        $this-&gt;extends = $extends;
        $this-&gt;implements = $implements;
        $this-&gt;constInfos = $constInfos;
        $this-&gt;propertyInfos = $propertyInfos;
        $this-&gt;funcInfos = $funcInfos;
        $this-&gt;enumCaseInfos = $enumCaseInfos;
        $this-&gt;cond = $cond;
        $this-&gt;phpVersionIdMinimumCompatibility = $minimumPhpVersionIdCompatibility;
        $this-&gt;isUndocumentable = $isUndocumentable;
    }

    /** @param array&lt;string, ConstInfo&gt; $allConstInfos */
    public function getRegistration(array $allConstInfos): string
    {
        $params = [];
        foreach ($this-&gt;extends as $extends) {
            $params[] = &quot;zend_class_entry *class_entry_&quot; . implode(&quot;_&quot;, $extends-&gt;getParts());
        }
        foreach ($this-&gt;implements as $implements) {
            $params[] = &quot;zend_class_entry *class_entry_&quot; . implode(&quot;_&quot;, $implements-&gt;getParts());
        }

        $escapedName = implode(&quot;_&quot;, $this-&gt;name-&gt;getParts());

        $code = &#039;&#039;;

        $php80MinimumCompatibility = $this-&gt;phpVersionIdMinimumCompatibility === null || $this-&gt;phpVersionIdMinimumCompatibility &gt;= PHP_80_VERSION_ID;
        $php81MinimumCompatibility = $this-&gt;phpVersionIdMinimumCompatibility === null || $this-&gt;phpVersionIdMinimumCompatibility &gt;= PHP_81_VERSION_ID;
        $php84MinimumCompatibility = $this-&gt;phpVersionIdMinimumCompatibility === null || $this-&gt;phpVersionIdMinimumCompatibility &gt;= PHP_84_VERSION_ID;

        if ($this-&gt;type === &quot;enum&quot; &amp;&amp; !$php81MinimumCompatibility) {
            $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_81_VERSION_ID . &quot;)\n&quot;;
        }

        if ($this-&gt;cond) {
            $code .= &quot;#if {$this-&gt;cond}\n&quot;;
        }

        $code .= &quot;static zend_class_entry *register_class_$escapedName(&quot; . (empty($params) ? &quot;void&quot; : implode(&quot;, &quot;, $params)) . &quot;)\n&quot;;

        $code .= &quot;{\n&quot;;

        $flagCodes = generateVersionDependentFlagCode(&quot;%s&quot;, $this-&gt;getFlagsByPhpVersion(), $this-&gt;phpVersionIdMinimumCompatibility);
        $flags = implode(&quot;&quot;, $flagCodes);

        $classMethods = ($this-&gt;funcInfos === []) ? &#039;NULL&#039; : &quot;class_{$escapedName}_methods&quot;;
        if ($this-&gt;type === &quot;enum&quot;) {
            $name = addslashes((string) $this-&gt;name);
            $backingType = $this-&gt;enumBackingType
                ? $this-&gt;enumBackingType-&gt;toTypeCode() : &quot;IS_UNDEF&quot;;
            $code .= &quot;\tzend_class_entry *class_entry = zend_register_internal_enum(\&quot;$name\&quot;, $backingType, $classMethods);\n&quot;;
            if ($flags !== &quot;&quot;) {
                $code .= &quot;\tclass_entry-&gt;ce_flags |= $flags\n&quot;;
            }
        } else {
            $code .= &quot;\tzend_class_entry ce, *class_entry;\n\n&quot;;
            if (count($this-&gt;name-&gt;getParts()) &gt; 1) {
                $className = $this-&gt;name-&gt;getLast();
                $namespace = addslashes((string) $this-&gt;name-&gt;slice(0, -1));

                $code .= &quot;\tINIT_NS_CLASS_ENTRY(ce, \&quot;$namespace\&quot;, \&quot;$className\&quot;, $classMethods);\n&quot;;
            } else {
                $code .= &quot;\tINIT_CLASS_ENTRY(ce, \&quot;$this-&gt;name\&quot;, $classMethods);\n&quot;;
            }

            if ($this-&gt;type === &quot;class&quot; || $this-&gt;type === &quot;trait&quot;) {
                if (!$php84MinimumCompatibility) {
                    $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_84_VERSION_ID . &quot;)\n&quot;;
                }

                $code .= &quot;\tclass_entry = zend_register_internal_class_with_flags(&amp;ce, &quot; . (isset($this-&gt;extends[0]) ? &quot;class_entry_&quot; . str_replace(&quot;\\&quot;, &quot;_&quot;, $this-&gt;extends[0]-&gt;toString()) : &quot;NULL&quot;) . &quot;, &quot; . ($flags ?: 0) . &quot;);\n&quot;;

                if (!$php84MinimumCompatibility) {
                    $code .= &quot;#else\n&quot;;

                    $code .= &quot;\tclass_entry = zend_register_internal_class_ex(&amp;ce, &quot; . (isset($this-&gt;extends[0]) ? &quot;class_entry_&quot; . str_replace(&quot;\\&quot;, &quot;_&quot;, $this-&gt;extends[0]-&gt;toString()) : &quot;NULL&quot;) . &quot;);\n&quot;;
                    if ($flags !== &quot;&quot;) {
                        $code .= &quot;\tclass_entry-&gt;ce_flags |= $flags;\n&quot;;
                    }
                    $code .= &quot;#endif\n&quot;;
                }
            } else {
                $code .= &quot;\tclass_entry = zend_register_internal_interface(&amp;ce);\n&quot;;
                if ($flags !== &quot;&quot;) {
                    $code .= &quot;\tclass_entry-&gt;ce_flags |= $flags\n&quot;;
                }
            }
        }

        if ($this-&gt;exposedDocComment) {
            if (!$php84MinimumCompatibility) {
                $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_84_VERSION_ID . &quot;)\n&quot;;
            }

            $code .= &quot;\tclass_entry-&gt;doc_comment = zend_string_init_interned(\&quot;&quot; . $this-&gt;exposedDocComment-&gt;escape() . &quot;\&quot;, &quot; . $this-&gt;exposedDocComment-&gt;getLength() . &quot;, 1);\n&quot;;

            if (!$php84MinimumCompatibility) {
                $code .= &quot;#endif\n&quot;;
            }
        }

        $implements = array_map(
            function (Name $item) {
                return &quot;class_entry_&quot; . implode(&quot;_&quot;, $item-&gt;getParts());
            },
            $this-&gt;type === &quot;interface&quot; ? $this-&gt;extends : $this-&gt;implements
        );

        if (!empty($implements)) {
            $code .= &quot;\tzend_class_implements(class_entry, &quot; . count($implements) . &quot;, &quot; . implode(&quot;, &quot;, $implements) . &quot;);\n&quot;;
        }

        if ($this-&gt;alias) {
            $code .= &quot;\tzend_register_class_alias(\&quot;&quot; . str_replace(&quot;\\&quot;, &quot;\\\\&quot;, $this-&gt;alias) . &quot;\&quot;, class_entry);\n&quot;;
        }

        foreach ($this-&gt;constInfos as $const) {
            $code .= $const-&gt;getDeclaration($allConstInfos);
        }

        foreach ($this-&gt;enumCaseInfos as $enumCase) {
            $code .= $enumCase-&gt;getDeclaration($allConstInfos);
        }

        foreach ($this-&gt;propertyInfos as $property) {
            $code .= $property-&gt;getDeclaration($allConstInfos);
        }

        if (!empty($this-&gt;attributes)) {
            if (!$php80MinimumCompatibility) {
                $code .= &quot;\n#if (PHP_VERSION_ID &gt;= &quot; . PHP_80_VERSION_ID . &quot;)&quot;;
            }

            foreach ($this-&gt;attributes as $key =&gt; $attribute) {
                $code .= $attribute-&gt;generateCode(
                    &quot;zend_add_class_attribute(class_entry&quot;,
                    &quot;class_{$escapedName}_$key&quot;,
                    $allConstInfos,
                    $this-&gt;phpVersionIdMinimumCompatibility
                );
            }

            if (!$php80MinimumCompatibility) {
                $code .= &quot;#endif\n&quot;;
            }
        }

        if ($attributeInitializationCode = generateConstantAttributeInitialization($this-&gt;constInfos, $allConstInfos, $this-&gt;phpVersionIdMinimumCompatibility, $this-&gt;cond)) {
            if (!$php80MinimumCompatibility) {
                $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_80_VERSION_ID . &quot;)&quot;;
            }

            $code .= &quot;\n&quot; . $attributeInitializationCode;

            if (!$php80MinimumCompatibility) {
                $code .= &quot;#endif\n&quot;;
            }
        }

        if ($attributeInitializationCode = generatePropertyAttributeInitialization($this-&gt;propertyInfos, $allConstInfos, $this-&gt;phpVersionIdMinimumCompatibility)) {
            if (!$php80MinimumCompatibility) {
                $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_80_VERSION_ID . &quot;)&quot;;
            }

            $code .= &quot;\n&quot; . $attributeInitializationCode;

            if (!$php80MinimumCompatibility) {
                $code .= &quot;#endif\n&quot;;
            }
        }

        if ($attributeInitializationCode = generateFunctionAttributeInitialization($this-&gt;funcInfos, $allConstInfos, $this-&gt;phpVersionIdMinimumCompatibility, $this-&gt;cond)) {
            if (!$php80MinimumCompatibility) {
                $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_80_VERSION_ID . &quot;)\n&quot;;
            }

            $code .= &quot;\n&quot; . $attributeInitializationCode;

            if (!$php80MinimumCompatibility) {
                $code .= &quot;#endif\n&quot;;
            }
        }

        $code .= &quot;\n\treturn class_entry;\n&quot;;

        $code .= &quot;}\n&quot;;

        if ($this-&gt;cond) {
            $code .= &quot;#endif\n&quot;;
        }

        if ($this-&gt;type === &quot;enum&quot; &amp;&amp; !$php81MinimumCompatibility) {
            $code .= &quot;#endif\n&quot;;
        }

        return $code;
    }

    /**
     * @return array&lt;int, string[]&gt;
     */
    private function getFlagsByPhpVersion(): array
    {
        $php70Flags = [];

        if ($this-&gt;type === &quot;trait&quot;) {
            $php70Flags[] = &quot;ZEND_ACC_TRAIT&quot;;
        }

        if ($this-&gt;flags &amp; Modifiers::FINAL) {
            $php70Flags[] = &quot;ZEND_ACC_FINAL&quot;;
        }

        if ($this-&gt;flags &amp; Modifiers::ABSTRACT) {
            $php70Flags[] = &quot;ZEND_ACC_ABSTRACT&quot;;
        }

        if ($this-&gt;isDeprecated) {
            $php70Flags[] = &quot;ZEND_ACC_DEPRECATED&quot;;
        }

        $php80Flags = $php70Flags;

        if ($this-&gt;isStrictProperties) {
            $php80Flags[] = &quot;ZEND_ACC_NO_DYNAMIC_PROPERTIES&quot;;
        }

        $php81Flags = $php80Flags;

        if ($this-&gt;isNotSerializable) {
            $php81Flags[] = &quot;ZEND_ACC_NOT_SERIALIZABLE&quot;;
        }

        $php82Flags = $php81Flags;

        if ($this-&gt;flags &amp; Modifiers::READONLY) {
            $php82Flags[] = &quot;ZEND_ACC_READONLY_CLASS&quot;;
        }

        foreach ($this-&gt;attributes as $attr) {
            if ($attr-&gt;class === &quot;AllowDynamicProperties&quot;) {
                $php82Flags[] = &quot;ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES&quot;;
                break;
            }
        }

        $php83Flags = $php82Flags;
        $php84Flags = $php83Flags;

        return [
            PHP_70_VERSION_ID =&gt; $php70Flags,
            PHP_80_VERSION_ID =&gt; $php80Flags,
            PHP_81_VERSION_ID =&gt; $php81Flags,
            PHP_82_VERSION_ID =&gt; $php82Flags,
            PHP_83_VERSION_ID =&gt; $php83Flags,
            PHP_84_VERSION_ID =&gt; $php84Flags,
        ];
    }

    public function discardInfoForOldPhpVersions(?int $phpVersionIdMinimumCompatibility): void {
        $this-&gt;attributes = [];
        $this-&gt;flags &amp;= ~Modifiers::READONLY;
        $this-&gt;exposedDocComment = null;
        $this-&gt;isStrictProperties = false;
        $this-&gt;isNotSerializable = false;

        foreach ($this-&gt;propertyInfos as $propertyInfo) {
            $propertyInfo-&gt;discardInfoForOldPhpVersions($phpVersionIdMinimumCompatibility);
        }
        $this-&gt;phpVersionIdMinimumCompatibility = $phpVersionIdMinimumCompatibility;
    }

    /**
     * @param array&lt;string, ClassInfo&gt; $classMap
     * @param array&lt;string, ConstInfo&gt; $allConstInfos
     * @param iterable&lt;ConstInfo&gt; $allConstInfo
     */
    public function getClassSynopsisDocument(array $classMap, array $allConstInfos): ?string {

        $doc = new DOMDocument();
        $doc-&gt;formatOutput = true;
        $classSynopsis = $this-&gt;getClassSynopsisElement($doc, $classMap, $allConstInfos);
        if (!$classSynopsis) {
            return null;
        }

        $doc-&gt;appendChild($classSynopsis);

        return $doc-&gt;saveXML();
    }

    /**
     * @param array&lt;string, ClassInfo&gt; $classMap
     * @param array&lt;string, ConstInfo&gt; $allConstInfos
     */
    public function getClassSynopsisElement(DOMDocument $doc, array $classMap, array $allConstInfos): ?DOMElement {

        $classSynopsis = $doc-&gt;createElement(&quot;classsynopsis&quot;);
        $classSynopsis-&gt;setAttribute(&quot;class&quot;, $this-&gt;type === &quot;interface&quot; ? &quot;interface&quot; : &quot;class&quot;);

        $exceptionOverride = $this-&gt;type === &quot;class&quot; &amp;&amp; $this-&gt;isException($classMap) ? &quot;exception&quot; : null;
        $ooElement = self::createOoElement($doc, $this, $exceptionOverride, true, null, 4);
        if (!$ooElement) {
            return null;
        }
        $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
        $classSynopsis-&gt;appendChild($ooElement);

        foreach ($this-&gt;extends as $k =&gt; $parent) {
            $parentInfo = $classMap[$parent-&gt;toString()] ?? null;
            if ($parentInfo === null) {
                throw new Exception(&quot;Missing parent class &quot; . $parent-&gt;toString());
            }

            $ooElement = self::createOoElement(
                $doc,
                $parentInfo,
                null,
                false,
                $k === 0 ? &quot;extends&quot; : null,
                4
            );
            if (!$ooElement) {
                return null;
            }

            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
            $classSynopsis-&gt;appendChild($ooElement);
        }

        foreach ($this-&gt;implements as $k =&gt; $interface) {
            $interfaceInfo = $classMap[$interface-&gt;toString()] ?? null;
            if (!$interfaceInfo) {
                throw new Exception(&quot;Missing implemented interface &quot; . $interface-&gt;toString());
            }

            $ooElement = self::createOoElement($doc, $interfaceInfo, null, false, $k === 0 ? &quot;implements&quot; : null, 4);
            if (!$ooElement) {
                return null;
            }
            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
            $classSynopsis-&gt;appendChild($ooElement);
        }

        /** @var array&lt;string, Name&gt; $parentsWithInheritedConstants */
        $parentsWithInheritedConstants = [];
        /** @var array&lt;string, Name&gt; $parentsWithInheritedProperties */
        $parentsWithInheritedProperties = [];
        /** @var array&lt;int, array{name: Name, types: int[]}&gt; $parentsWithInheritedMethods */
        $parentsWithInheritedMethods = [];

        $this-&gt;collectInheritedMembers(
            $parentsWithInheritedConstants,
            $parentsWithInheritedProperties,
            $parentsWithInheritedMethods,
            $this-&gt;hasConstructor(),
            $classMap
        );

        $this-&gt;appendInheritedMemberSectionToClassSynopsis(
            $doc,
            $classSynopsis,
            $parentsWithInheritedConstants,
            &quot;&amp;Constants;&quot;,
            &quot;&amp;InheritedConstants;&quot;
        );

        if (!empty($this-&gt;constInfos)) {
            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
            $classSynopsisInfo = $doc-&gt;createElement(&quot;classsynopsisinfo&quot;, &quot;&amp;Constants;&quot;);
            $classSynopsisInfo-&gt;setAttribute(&quot;role&quot;, &quot;comment&quot;);
            $classSynopsis-&gt;appendChild($classSynopsisInfo);

            foreach ($this-&gt;constInfos as $constInfo) {
                $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                $fieldSynopsisElement = $constInfo-&gt;getFieldSynopsisElement($doc, $allConstInfos);
                $classSynopsis-&gt;appendChild($fieldSynopsisElement);
            }
        }

        if (!empty($this-&gt;propertyInfos)) {
            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
            $classSynopsisInfo = $doc-&gt;createElement(&quot;classsynopsisinfo&quot;, &quot;&amp;Properties;&quot;);
            $classSynopsisInfo-&gt;setAttribute(&quot;role&quot;, &quot;comment&quot;);
            $classSynopsis-&gt;appendChild($classSynopsisInfo);

            foreach ($this-&gt;propertyInfos as $propertyInfo) {
                $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                $fieldSynopsisElement = $propertyInfo-&gt;getFieldSynopsisElement($doc, $allConstInfos);
                $classSynopsis-&gt;appendChild($fieldSynopsisElement);
            }
        }

        $this-&gt;appendInheritedMemberSectionToClassSynopsis(
            $doc,
            $classSynopsis,
            $parentsWithInheritedProperties,
            &quot;&amp;Properties;&quot;,
            &quot;&amp;InheritedProperties;&quot;
        );

        if (!empty($this-&gt;funcInfos)) {
            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
            $classSynopsisInfo = $doc-&gt;createElement(&quot;classsynopsisinfo&quot;, &quot;&amp;Methods;&quot;);
            $classSynopsisInfo-&gt;setAttribute(&quot;role&quot;, &quot;comment&quot;);
            $classSynopsis-&gt;appendChild($classSynopsisInfo);

            $classReference = self::getClassSynopsisReference($this-&gt;name);
            $escapedName = addslashes($this-&gt;name-&gt;__toString());

            if ($this-&gt;hasConstructor()) {
                $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                $includeElement = $this-&gt;createIncludeElement(
                    $doc,
                    &quot;xmlns(db=http://docbook.org/ns/docbook) xpointer(id(&#039;$classReference&#039;)/db:refentry/db:refsect1[@role=&#039;description&#039;]/descendant::db:constructorsynopsis[@role=&#039;$escapedName&#039;])&quot;
                );
                $classSynopsis-&gt;appendChild($includeElement);
            }

            if ($this-&gt;hasMethods()) {
                $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                $includeElement = $this-&gt;createIncludeElement(
                    $doc,
                    &quot;xmlns(db=http://docbook.org/ns/docbook) xpointer(id(&#039;$classReference&#039;)/db:refentry/db:refsect1[@role=&#039;description&#039;]/descendant::db:methodsynopsis[@role=&#039;$escapedName&#039;])&quot;
                );
                $classSynopsis-&gt;appendChild($includeElement);
            }

            if ($this-&gt;hasDestructor()) {
                $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                $includeElement = $this-&gt;createIncludeElement(
                    $doc,
                    &quot;xmlns(db=http://docbook.org/ns/docbook) xpointer(id(&#039;$classReference&#039;)/db:refentry/db:refsect1[@role=&#039;description&#039;]/descendant::db:destructorsynopsis[@role=&#039;$escapedName&#039;])&quot;
                );
                $classSynopsis-&gt;appendChild($includeElement);
            }
        }

        if (!empty($parentsWithInheritedMethods)) {
            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
            $classSynopsisInfo = $doc-&gt;createElement(&quot;classsynopsisinfo&quot;, &quot;&amp;InheritedMethods;&quot;);
            $classSynopsisInfo-&gt;setAttribute(&quot;role&quot;, &quot;comment&quot;);
            $classSynopsis-&gt;appendChild($classSynopsisInfo);

            foreach ($parentsWithInheritedMethods as $parent) {
                $parentName = $parent[&quot;name&quot;];
                $parentMethodsynopsisTypes = $parent[&quot;types&quot;];

                $parentReference = self::getClassSynopsisReference($parentName);
                $escapedParentName = addslashes($parentName-&gt;__toString());

                foreach ($parentMethodsynopsisTypes as $parentMethodsynopsisType) {
                    $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
                    $includeElement = $this-&gt;createIncludeElement(
                        $doc,
                        &quot;xmlns(db=http://docbook.org/ns/docbook) xpointer(id(&#039;$parentReference&#039;)/db:refentry/db:refsect1[@role=&#039;description&#039;]/descendant::db:{$parentMethodsynopsisType}[@role=&#039;$escapedParentName&#039;])&quot;
                    );

                    $classSynopsis-&gt;appendChild($includeElement);
                }
            }
        }

        $classSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));

        return $classSynopsis;
    }

    private static function createOoElement(
        DOMDocument $doc,
        ClassInfo $classInfo,
        ?string $typeOverride,
        bool $withModifiers,
        ?string $modifierOverride,
        int $indentationLevel
    ): ?DOMElement {
        $indentation = str_repeat(&quot; &quot;, $indentationLevel);

        if ($classInfo-&gt;type !== &quot;class&quot; &amp;&amp; $classInfo-&gt;type !== &quot;interface&quot;) {
            echo &quot;Class synopsis generation is not implemented for &quot; . $classInfo-&gt;type . &quot;\n&quot;;
            return null;
        }

        $type = $typeOverride !== null ? $typeOverride : $classInfo-&gt;type;

        $ooElement = $doc-&gt;createElement(&quot;oo$type&quot;);
        $ooElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
        if ($modifierOverride !== null) {
            $ooElement-&gt;appendChild($doc-&gt;createElement(&#039;modifier&#039;, $modifierOverride));
            $ooElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
        } elseif ($withModifiers) {
            if ($classInfo-&gt;flags &amp; Modifiers::FINAL) {
                $ooElement-&gt;appendChild($doc-&gt;createElement(&#039;modifier&#039;, &#039;final&#039;));
                $ooElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
            }
            if ($classInfo-&gt;flags &amp; Modifiers::ABSTRACT) {
                $ooElement-&gt;appendChild($doc-&gt;createElement(&#039;modifier&#039;, &#039;abstract&#039;));
                $ooElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
            }
            if ($classInfo-&gt;flags &amp; Modifiers::READONLY) {
                $ooElement-&gt;appendChild($doc-&gt;createElement(&#039;modifier&#039;, &#039;readonly&#039;));
                $ooElement-&gt;appendChild(new DOMText(&quot;\n$indentation &quot;));
            }
        }

        $nameElement = $doc-&gt;createElement(&quot;{$type}name&quot;, $classInfo-&gt;name-&gt;toString());
        $ooElement-&gt;appendChild($nameElement);
        $ooElement-&gt;appendChild(new DOMText(&quot;\n$indentation&quot;));

        return $ooElement;
    }

    public static function getClassSynopsisFilename(Name $name): string {
        return strtolower(str_replace(&quot;_&quot;, &quot;-&quot;, implode(&#039;-&#039;, $name-&gt;getParts())));
    }

    public static function getClassSynopsisReference(Name $name): string {
        return &quot;class.&quot; . self::getClassSynopsisFilename($name);
    }

    /**
     * @param array&lt;string, Name&gt; $parentsWithInheritedConstants
     * @param array&lt;string, Name&gt; $parentsWithInheritedProperties
     * @param array&lt;string, array{name: Name, types: int[]}&gt; $parentsWithInheritedMethods
     * @param array&lt;string, ClassInfo&gt; $classMap
     */
    private function collectInheritedMembers(
        array &amp;$parentsWithInheritedConstants,
        array &amp;$parentsWithInheritedProperties,
        array &amp;$parentsWithInheritedMethods,
        bool $hasConstructor,
        array $classMap
    ): void {
        foreach ($this-&gt;extends as $parent) {
            $parentInfo = $classMap[$parent-&gt;toString()] ?? null;
            $parentName = $parent-&gt;toString();

            if (!$parentInfo) {
                throw new Exception(&quot;Missing parent class $parentName&quot;);
            }

            if (!empty($parentInfo-&gt;constInfos) &amp;&amp; !isset($parentsWithInheritedConstants[$parentName])) {
                $parentsWithInheritedConstants[] = $parent;
            }

            if (!empty($parentInfo-&gt;propertyInfos) &amp;&amp; !isset($parentsWithInheritedProperties[$parentName])) {
                $parentsWithInheritedProperties[$parentName] = $parent;
            }

            if (!$hasConstructor &amp;&amp; $parentInfo-&gt;hasNonPrivateConstructor()) {
                $parentsWithInheritedMethods[$parentName][&quot;name&quot;] = $parent;
                $parentsWithInheritedMethods[$parentName][&quot;types&quot;][] = &quot;constructorsynopsis&quot;;
            }

            if ($parentInfo-&gt;hasMethods()) {
                $parentsWithInheritedMethods[$parentName][&quot;name&quot;] = $parent;
                $parentsWithInheritedMethods[$parentName][&quot;types&quot;][] = &quot;methodsynopsis&quot;;
            }

            if ($parentInfo-&gt;hasDestructor()) {
                $parentsWithInheritedMethods[$parentName][&quot;name&quot;] = $parent;
                $parentsWithInheritedMethods[$parentName][&quot;types&quot;][] = &quot;destructorsynopsis&quot;;
            }

            $parentInfo-&gt;collectInheritedMembers(
                $parentsWithInheritedConstants,
                $parentsWithInheritedProperties,
                $parentsWithInheritedMethods,
                $hasConstructor,
                $classMap
            );
        }

        foreach ($this-&gt;implements as $parent) {
            $parentInfo = $classMap[$parent-&gt;toString()] ?? null;
            if (!$parentInfo) {
                throw new Exception(&quot;Missing parent interface &quot; . $parent-&gt;toString());
            }

            if (!empty($parentInfo-&gt;constInfos) &amp;&amp; !isset($parentsWithInheritedConstants[$parent-&gt;toString()])) {
                $parentsWithInheritedConstants[$parent-&gt;toString()] = $parent;
            }

            $unusedParentsWithInheritedProperties = [];
            $unusedParentsWithInheritedMethods = [];

            $parentInfo-&gt;collectInheritedMembers(
                $parentsWithInheritedConstants,
                $unusedParentsWithInheritedProperties,
                $unusedParentsWithInheritedMethods,
                $hasConstructor,
                $classMap
            );
        }
    }

    /** @param array&lt;string, ClassInfo&gt; $classMap */
    private function isException(array $classMap): bool
    {
        if ($this-&gt;name-&gt;toString() === &quot;Throwable&quot;) {
            return true;
        }

        foreach ($this-&gt;extends as $parentName) {
            $parent = $classMap[$parentName-&gt;toString()] ?? null;
            if ($parent === null) {
                throw new Exception(&quot;Missing parent class &quot; . $parentName-&gt;toString());
            }

            if ($parent-&gt;isException($classMap)) {
                return true;
            }
        }

        if ($this-&gt;type === &quot;class&quot;) {
            foreach ($this-&gt;implements as $interfaceName) {
                $interface = $classMap[$interfaceName-&gt;toString()] ?? null;
                if ($interface === null) {
                    throw new Exception(&quot;Missing implemented interface &quot; . $interfaceName-&gt;toString());
                }

                if ($interface-&gt;isException($classMap)) {
                    return true;
                }
            }
        }

        return false;
    }

    private function hasConstructor(): bool
    {
        foreach ($this-&gt;funcInfos as $funcInfo) {
            if ($funcInfo-&gt;name-&gt;isConstructor()) {
                return true;
            }
        }

        return false;
    }

    private function hasNonPrivateConstructor(): bool
    {
        foreach ($this-&gt;funcInfos as $funcInfo) {
            if ($funcInfo-&gt;name-&gt;isConstructor() &amp;&amp; !($funcInfo-&gt;flags &amp; Modifiers::PRIVATE)) {
                return true;
            }
        }

        return false;
    }

    private function hasDestructor(): bool
    {
        foreach ($this-&gt;funcInfos as $funcInfo) {
            if ($funcInfo-&gt;name-&gt;isDestructor()) {
                return true;
            }
        }

        return false;
    }

    private function hasMethods(): bool
    {
        foreach ($this-&gt;funcInfos as $funcInfo) {
            if (!$funcInfo-&gt;name-&gt;isConstructor() &amp;&amp; !$funcInfo-&gt;name-&gt;isDestructor()) {
                return true;
            }
        }

        return false;
    }

    private function createIncludeElement(DOMDocument $doc, string $query): DOMElement
    {
        $includeElement = $doc-&gt;createElement(&quot;xi:include&quot;);
        $attr = $doc-&gt;createAttribute(&quot;xpointer&quot;);
        $attr-&gt;value = $query;
        $includeElement-&gt;appendChild($attr);
        $fallbackElement = $doc-&gt;createElement(&quot;xi:fallback&quot;);
        $includeElement-&gt;appendChild(new DOMText(&quot;\n     &quot;));
        $includeElement-&gt;appendChild($fallbackElement);
        $includeElement-&gt;appendChild(new DOMText(&quot;\n    &quot;));

        return $includeElement;
    }

    public function __clone()
    {
        foreach ($this-&gt;constInfos as $key =&gt; $constInfo) {
            $this-&gt;constInfos[$key] = clone $constInfo;
        }

        foreach ($this-&gt;propertyInfos as $key =&gt; $propertyInfo) {
            $this-&gt;propertyInfos[$key] = clone $propertyInfo;
        }

        foreach ($this-&gt;funcInfos as $key =&gt; $funcInfo) {
            $this-&gt;funcInfos[$key] = clone $funcInfo;
        }

        foreach ($this-&gt;attributes as $key =&gt; $attribute) {
            $this-&gt;attributes[$key] = clone $attribute;
        }

        if ($this-&gt;exposedDocComment) {
            $this-&gt;exposedDocComment = clone $this-&gt;exposedDocComment;
        }
    }

    /**
     * @param Name[] $parents
     */
    private function appendInheritedMemberSectionToClassSynopsis(DOMDocument $doc, DOMElement $classSynopsis, array $parents, string $label, string $inheritedLabel): void
    {
        if (empty($parents)) {
            return;
        }

        $classSynopsis-&gt;appendChild(new DOMText(&quot;\n\n    &quot;));
        $classSynopsisInfo = $doc-&gt;createElement(&quot;classsynopsisinfo&quot;, &quot;$inheritedLabel&quot;);
        $classSynopsisInfo-&gt;setAttribute(&quot;role&quot;, &quot;comment&quot;);
        $classSynopsis-&gt;appendChild($classSynopsisInfo);

        foreach ($parents as $parent) {
            $classSynopsis-&gt;appendChild(new DOMText(&quot;\n    &quot;));
            $parentReference = self::getClassSynopsisReference($parent);

            $includeElement = $this-&gt;createIncludeElement(
                $doc,
                &quot;xmlns(db=http://docbook.org/ns/docbook) xpointer(id(&#039;$parentReference&#039;)/db:partintro/db:section/db:classsynopsis/db:fieldsynopsis[preceding-sibling::db:classsynopsisinfo[1][@role=&#039;comment&#039; and text()=&#039;$label&#039;]]))&quot;
            );
            $classSynopsis-&gt;appendChild($includeElement);
        }
    }
}

class FileInfo {
    /** @var string[] */
    public array $dependencies = [];
    /** @var ConstInfo[] */
    public array $constInfos = [];
    /** @var FuncInfo[] */
    public array $funcInfos = [];
    /** @var ClassInfo[] */
    public array $classInfos = [];
    public bool $generateFunctionEntries = false;
    public string $declarationPrefix = &quot;&quot;;
    public bool $generateClassEntries = false;
    public bool $isUndocumentable = false;
    public bool $legacyArginfoGeneration = false;
    private ?int $minimumPhpVersionIdCompatibility = null;

    /**
     * @return iterable&lt;FuncInfo&gt;
     */
    public function getAllFuncInfos(): iterable {
        yield from $this-&gt;funcInfos;
        foreach ($this-&gt;classInfos as $classInfo) {
            yield from $classInfo-&gt;funcInfos;
        }
    }

    /** @return array&lt;string, ConstInfo&gt; */
    public function getAllConstInfos(): array {
        $result = [];

        foreach ($this-&gt;constInfos as $constInfo) {
            $result[$constInfo-&gt;name-&gt;__toString()] = $constInfo;
        }

        foreach ($this-&gt;classInfos as $classInfo) {
            foreach ($classInfo-&gt;constInfos as $constInfo) {
                $result[$constInfo-&gt;name-&gt;__toString()] = $constInfo;
            }
        }

        return $result;
    }

    /**
     * @return iterable&lt;ClassInfo&gt;
     */
    public function getAllClassInfos(): iterable {
        foreach ($this-&gt;classInfos as $classInfo) {
            yield $classInfo;
        }
    }

    public function __clone()
    {
        foreach ($this-&gt;constInfos as $key =&gt; $constInfo) {
            $this-&gt;constInfos[$key] = clone $constInfo;
        }

        foreach ($this-&gt;funcInfos as $key =&gt; $funcInfo) {
            $this-&gt;funcInfos[$key] = clone $funcInfo;
        }

        foreach ($this-&gt;classInfos as $key =&gt; $classInfo) {
            $this-&gt;classInfos[$key] = clone $classInfo;
        }
    }

    public function setMinimumPhpVersionIdCompatibility(?int $minimumPhpVersionIdCompatibility) {
        $this-&gt;minimumPhpVersionIdCompatibility = $minimumPhpVersionIdCompatibility;
    }

    public function getMinimumPhpVersionIdCompatibility(): ?int {
        // Non-legacy arginfo files are always PHP 8.0+ compatible
        if (!$this-&gt;legacyArginfoGeneration &amp;&amp;
            $this-&gt;minimumPhpVersionIdCompatibility !== null &amp;&amp;
            $this-&gt;minimumPhpVersionIdCompatibility &lt; PHP_80_VERSION_ID
        ) {
            return PHP_80_VERSION_ID;
        }

        return $this-&gt;minimumPhpVersionIdCompatibility;
    }

    public function shouldGenerateLegacyArginfo(): bool {
        return $this-&gt;minimumPhpVersionIdCompatibility !== null &amp;&amp; $this-&gt;minimumPhpVersionIdCompatibility &lt; PHP_80_VERSION_ID;
    }
}

class DocCommentTag {
    public string $name;
    public ?string $value;

    public function __construct(string $name, ?string $value) {
        $this-&gt;name = $name;
        $this-&gt;value = $value;
    }

    public function getValue(): string {
        if ($this-&gt;value === null) {
            throw new Exception(&quot;@$this-&gt;name does not have a value&quot;);
        }

        return $this-&gt;value;
    }

    public function getType(): string {
        $value = $this-&gt;getValue();

        $matches = [];

        if ($this-&gt;name === &quot;param&quot;) {
            preg_match(&#039;/^\s*([\w\|\\\\\[\]&lt;&gt;, ]+)\s*(?:[{(]|\$\w+).*$/&#039;, $value, $matches);
        } elseif ($this-&gt;name === &quot;return&quot; || $this-&gt;name === &quot;var&quot;) {
            preg_match(&#039;/^\s*([\w\|\\\\\[\]&lt;&gt;, ]+)/&#039;, $value, $matches);
        }

        if (!isset($matches[1])) {
            throw new Exception(&quot;@$this-&gt;name doesn&#039;t contain a type or has an invalid format \&quot;$value\&quot;&quot;);
        }

        return trim($matches[1]);
    }

    public function getVariableName(): string {
        $value = $this-&gt;value;
        if ($value === null || strlen($value) === 0) {
            throw new Exception(&quot;@$this-&gt;name doesn&#039;t have any value&quot;);
        }

        $matches = [];

        if ($this-&gt;name === &quot;param&quot;) {
            // Allow for parsing extended types like callable(string):mixed in docblocks
            preg_match(&#039;/^\s*(?&lt;type&gt;[\w\|\\\\]+(?&lt;parens&gt;\((?&lt;inparens&gt;(?:(?&amp;parens)|[^(){}[\]]*+))++\)|\{(?&amp;inparens)\}|\[(?&amp;inparens)\])*+(?::(?&amp;type))?)\s*\$(?&lt;name&gt;\w+).*$/&#039;, $value, $matches);
        } elseif ($this-&gt;name === &quot;prefer-ref&quot;) {
            preg_match(&#039;/^\s*\$(?&lt;name&gt;\w+).*$/&#039;, $value, $matches);
        }

        if (!isset($matches[&quot;name&quot;])) {
            throw new Exception(&quot;@$this-&gt;name doesn&#039;t contain a variable name or has an invalid format \&quot;$value\&quot;&quot;);
        }

        return $matches[&quot;name&quot;];
    }
}

class ExposedDocComment {
    private string $docComment;

    public function __construct(string $docComment) {
        $this-&gt;docComment = $docComment;
    }

    public function escape(): string {
        return str_replace(&quot;\n&quot;, &#039;\n&#039;, addslashes($this-&gt;docComment));
    }

    public function getLength(): int {
        return strlen($this-&gt;docComment);
    }
}

/** @return DocCommentTag[] */
function parseDocComments(array $comments): array {
    $tags = [];
    foreach ($comments as $comment) {
        if ($comment instanceof DocComment) {
            $tags = array_merge($tags, parseDocComment($comment));
        }
    }

    return $tags;
}

/** @return DocCommentTag[] */
function parseDocComment(DocComment $comment): array {
    $commentText = substr($comment-&gt;getText(), 2, -2);
    $tags = [];
    foreach (explode(&quot;\n&quot;, $commentText) as $commentLine) {
        $regex = &#039;/^\*\s*@([a-z-]+)(?:\s+(.+))?$/&#039;;
        if (preg_match($regex, trim($commentLine), $matches)) {
            $tags[] = new DocCommentTag($matches[1], $matches[2] ?? null);
        }
    }

    return $tags;
}

class FramelessFunctionInfo {
    public int $arity;
}

function parseFramelessFunctionInfo(string $json): FramelessFunctionInfo {
    // FIXME: Should have some validation
    $json = json_decode($json, true);
    $framelessFunctionInfo = new FramelessFunctionInfo();
    $framelessFunctionInfo-&gt;arity = $json[&quot;arity&quot;];
    return $framelessFunctionInfo;
}

function parseFunctionLike(
    PrettyPrinterAbstract $prettyPrinter,
    FunctionOrMethodName $name,
    int $classFlags,
    int $flags,
    Node\FunctionLike $func,
    ?string $cond,
    bool $isUndocumentable,
    ?int $minimumPhpVersionIdCompatibility
): FuncInfo {
    try {
        $comments = $func-&gt;getComments();
        $paramMeta = [];
        $aliasType = null;
        $alias = null;
        $isDeprecated = false;
        $supportsCompileTimeEval = false;
        $verify = true;
        $docReturnType = null;
        $tentativeReturnType = false;
        $docParamTypes = [];
        $refcount = null;
        $framelessFunctionInfos = [];

        if ($comments) {
            $tags = parseDocComments($comments);

            foreach ($tags as $tag) {
                switch ($tag-&gt;name) {
                    case &#039;alias&#039;:
                    case &#039;implementation-alias&#039;:
                        $aliasType = $tag-&gt;name;
                        $aliasParts = explode(&quot;::&quot;, $tag-&gt;getValue());
                        if (count($aliasParts) === 1) {
                            $alias = new FunctionName(new Name($aliasParts[0]));
                        } else {
                            $alias = new MethodName(new Name($aliasParts[0]), $aliasParts[1]);
                        }
                        break;

                    case &#039;deprecated&#039;:
                        $isDeprecated = true;
                        break;

                    case &#039;no-verify&#039;:
                        $verify = false;
                        break;

                    case &#039;tentative-return-type&#039;:
                        $tentativeReturnType = true;
                        break;

                    case &#039;return&#039;:
                        $docReturnType = $tag-&gt;getType();
                        break;

                    case &#039;param&#039;:
                        $docParamTypes[$tag-&gt;getVariableName()] = $tag-&gt;getType();
                        break;

                    case &#039;refcount&#039;:
                        $refcount = $tag-&gt;getValue();
                        break;

                    case &#039;compile-time-eval&#039;:
                        $supportsCompileTimeEval = true;
                        break;

                    case &#039;prefer-ref&#039;:
                        $varName = $tag-&gt;getVariableName();
                        if (!isset($paramMeta[$varName])) {
                            $paramMeta[$varName] = [];
                        }
                        $paramMeta[$varName][$tag-&gt;name] = true;
                        break;

                    case &#039;undocumentable&#039;:
                        $isUndocumentable = true;
                        break;

                    case &#039;frameless-function&#039;:
                        $framelessFunctionInfos[] = parseFramelessFunctionInfo($tag-&gt;getValue());
                        break;
                }
            }
        }

        $varNameSet = [];
        $args = [];
        $numRequiredArgs = 0;
        $foundVariadic = false;
        foreach ($func-&gt;getParams() as $i =&gt; $param) {
            if ($param-&gt;isPromoted()) {
                throw new Exception(&quot;Promoted properties are not supported&quot;);
            }

            $varName = $param-&gt;var-&gt;name;
            $preferRef = !empty($paramMeta[$varName][&#039;prefer-ref&#039;]);
            unset($paramMeta[$varName]);

            if (isset($varNameSet[$varName])) {
                throw new Exception(&quot;Duplicate parameter name $varName&quot;);
            }
            $varNameSet[$varName] = true;

            if ($preferRef) {
                $sendBy = ArgInfo::SEND_PREFER_REF;
            } else if ($param-&gt;byRef) {
                $sendBy = ArgInfo::SEND_BY_REF;
            } else {
                $sendBy = ArgInfo::SEND_BY_VAL;
            }

            if ($foundVariadic) {
                throw new Exception(&quot;Only the last parameter can be variadic&quot;);
            }

            $type = $param-&gt;type ? Type::fromNode($param-&gt;type) : null;
            if ($type === null &amp;&amp; !isset($docParamTypes[$varName])) {
                throw new Exception(&quot;Missing parameter type&quot;);
            }

            if ($param-&gt;default instanceof Expr\ConstFetch &amp;&amp;
                $param-&gt;default-&gt;name-&gt;toLowerString() === &quot;null&quot; &amp;&amp;
                $type &amp;&amp; !$type-&gt;isNullable()
            ) {
                $simpleType = $type-&gt;tryToSimpleType();
                if ($simpleType === null || !$simpleType-&gt;isMixed()) {
                    throw new Exception(&quot;Parameter $varName has null default, but is not nullable&quot;);
                }
            }

            if ($param-&gt;default instanceof Expr\ClassConstFetch &amp;&amp; $param-&gt;default-&gt;class-&gt;toLowerString() === &quot;self&quot;) {
                throw new Exception(&#039;The exact class name must be used instead of &quot;self&quot;&#039;);
            }

            $foundVariadic = $param-&gt;variadic;

            $args[] = new ArgInfo(
                $varName,
                $sendBy,
                $param-&gt;variadic,
                $type,
                isset($docParamTypes[$varName]) ? Type::fromString($docParamTypes[$varName]) : null,
                $param-&gt;default ? $prettyPrinter-&gt;prettyPrintExpr($param-&gt;default) : null,
                createAttributes($param-&gt;attrGroups)
            );
            if (!$param-&gt;default &amp;&amp; !$param-&gt;variadic) {
                $numRequiredArgs = $i + 1;
            }
        }

        foreach (array_keys($paramMeta) as $var) {
            throw new Exception(&quot;Found metadata for invalid param $var&quot;);
        }

        $returnType = $func-&gt;getReturnType();
        if ($returnType === null &amp;&amp; $docReturnType === null &amp;&amp; !$name-&gt;isConstructor() &amp;&amp; !$name-&gt;isDestructor()) {
            throw new Exception(&quot;Missing return type&quot;);
        }

        $return = new ReturnInfo(
            $func-&gt;returnsByRef(),
            $returnType ? Type::fromNode($returnType) : null,
            $docReturnType ? Type::fromString($docReturnType) : null,
            $tentativeReturnType,
            $refcount
        );

        return new FuncInfo(
            $name,
            $classFlags,
            $flags,
            $aliasType,
            $alias,
            $isDeprecated,
            $supportsCompileTimeEval,
            $verify,
            $args,
            $return,
            $numRequiredArgs,
            $cond,
            $isUndocumentable,
            $minimumPhpVersionIdCompatibility,
            createAttributes($func-&gt;attrGroups),
            $framelessFunctionInfos,
            createExposedDocComment($comments)
        );
    } catch (Exception $e) {
        throw new Exception($name . &quot;(): &quot; .$e-&gt;getMessage());
    }
}

/**
 * @param array&lt;int, array&lt;int, AttributeGroup&gt; $attributes
 */
function parseConstLike(
    PrettyPrinterAbstract $prettyPrinter,
    ConstOrClassConstName $name,
    Node\Const_ $const,
    int $flags,
    ?Node $type,
    array $comments,
    ?string $cond,
    bool $isUndocumentable,
    ?int $phpVersionIdMinimumCompatibility,
    array $attributes
): ConstInfo {
    $phpDocType = null;
    $deprecated = false;
    $cValue = null;
    $link = null;
    $isFileCacheAllowed = true;
    if ($comments) {
        $tags = parseDocComments($comments);
        foreach ($tags as $tag) {
            if ($tag-&gt;name === &#039;var&#039;) {
                $phpDocType = $tag-&gt;getType();
            } elseif ($tag-&gt;name === &#039;deprecated&#039;) {
                $deprecated = true;
            } elseif ($tag-&gt;name === &#039;cvalue&#039;) {
                $cValue = $tag-&gt;value;
            } elseif ($tag-&gt;name === &#039;undocumentable&#039;) {
                $isUndocumentable = true;
            } elseif ($tag-&gt;name === &#039;link&#039;) {
                $link = $tag-&gt;value;
            } elseif ($tag-&gt;name === &#039;no-file-cache&#039;) {
                $isFileCacheAllowed = false;
            }
        }
    }

    if ($type === null &amp;&amp; $phpDocType === null) {
        throw new Exception(&quot;Missing type for constant &quot; . $name-&gt;__toString());
    }

    $constType = $type ? Type::fromNode($type) : null;
    $constPhpDocType = $phpDocType ? Type::fromString($phpDocType) : null;

    if ($const-&gt;value instanceof Expr\ConstFetch &amp;&amp;
        $const-&gt;value-&gt;name-&gt;toLowerString() === &quot;null&quot; &amp;&amp;
        $constType &amp;&amp; !$constType-&gt;isNullable()
    ) {
        $simpleType = $constType-&gt;tryToSimpleType();
        if ($simpleType === null || !$simpleType-&gt;isMixed()) {
            throw new Exception(&quot;Constant &quot; . $name-&gt;__toString() . &quot; has null value, but is not nullable&quot;);
        }
    }

    return new ConstInfo(
        $name,
        $flags,
        $const-&gt;value,
        $prettyPrinter-&gt;prettyPrintExpr($const-&gt;value),
        $constType,
        $constPhpDocType,
        $deprecated,
        $cond,
        $cValue,
        $isUndocumentable,
        $link,
        $phpVersionIdMinimumCompatibility,
        $attributes,
        createExposedDocComment($comments),
        $isFileCacheAllowed
    );
}

/**
 * @param array&lt;int, array&lt;int, AttributeGroup&gt; $attributes
 */
function parseProperty(
    Name $class,
    int $classFlags,
    int $flags,
    Stmt\PropertyProperty $property,
    ?Node $type,
    array $comments,
    PrettyPrinterAbstract $prettyPrinter,
    ?int $phpVersionIdMinimumCompatibility,
    array $attributes
): PropertyInfo {
    $phpDocType = null;
    $isDocReadonly = false;
    $isVirtual = false;
    $link = null;

    if ($comments) {
        $tags = parseDocComments($comments);
        foreach ($tags as $tag) {
            if ($tag-&gt;name === &#039;var&#039;) {
                $phpDocType = $tag-&gt;getType();
            } elseif ($tag-&gt;name === &#039;readonly&#039;) {
                $isDocReadonly = true;
            } elseif ($tag-&gt;name === &#039;link&#039;) {
                $link = $tag-&gt;value;
            } elseif ($tag-&gt;name === &#039;virtual&#039;) {
                $isVirtual = true;
            }
        }
    }

    $propertyType = $type ? Type::fromNode($type) : null;
    if ($propertyType === null &amp;&amp; !$phpDocType) {
        throw new Exception(&quot;Missing type for property $class::\$$property-&gt;name&quot;);
    }

    if ($property-&gt;default instanceof Expr\ConstFetch &amp;&amp;
        $property-&gt;default-&gt;name-&gt;toLowerString() === &quot;null&quot; &amp;&amp;
        $propertyType &amp;&amp; !$propertyType-&gt;isNullable()
    ) {
        $simpleType = $propertyType-&gt;tryToSimpleType();
        if ($simpleType === null || !$simpleType-&gt;isMixed()) {
            throw new Exception(&quot;Property $class::\$$property-&gt;name has null default, but is not nullable&quot;);
        }
    }

    return new PropertyInfo(
        new PropertyName($class, $property-&gt;name-&gt;__toString()),
        $classFlags,
        $flags,
        $propertyType,
        $phpDocType ? Type::fromString($phpDocType) : null,
        $property-&gt;default,
        $property-&gt;default ? $prettyPrinter-&gt;prettyPrintExpr($property-&gt;default) : null,
        $isDocReadonly,
        $isVirtual,
        $link,
        $phpVersionIdMinimumCompatibility,
        $attributes,
        createExposedDocComment($comments)
    );
}

/**
 * @param ConstInfo[] $consts
 * @param PropertyInfo[] $properties
 * @param FuncInfo[] $methods
 * @param EnumCaseInfo[] $enumCases
 */
function parseClass(
    Name $name,
    Stmt\ClassLike $class,
    array $consts,
    array $properties,
    array $methods,
    array $enumCases,
    ?string $cond,
    ?int $minimumPhpVersionIdCompatibility,
    bool $isUndocumentable
): ClassInfo {
    $flags = $class instanceof Class_ ? $class-&gt;flags : 0;
    $comments = $class-&gt;getComments();
    $alias = null;
    $isDeprecated = false;
    $isStrictProperties = false;
    $isNotSerializable = false;
    $allowsDynamicProperties = false;
    $attributes = [];

    if ($comments) {
        $tags = parseDocComments($comments);
        foreach ($tags as $tag) {
            if ($tag-&gt;name === &#039;alias&#039;) {
                $alias = $tag-&gt;getValue();
            } else if ($tag-&gt;name === &#039;deprecated&#039;) {
                $isDeprecated = true;
            } else if ($tag-&gt;name === &#039;strict-properties&#039;) {
                $isStrictProperties = true;
            } else if ($tag-&gt;name === &#039;not-serializable&#039;) {
                $isNotSerializable = true;
            } else if ($tag-&gt;name === &#039;undocumentable&#039;) {
                $isUndocumentable = true;
            }
        }
    }

    $attributes = createAttributes($class-&gt;attrGroups);
    foreach ($attributes as $attribute) {
        switch ($attribute-&gt;class) {
            case &#039;AllowDynamicProperties&#039;:
                $allowsDynamicProperties = true;
                break 2;
        }
    }

    if ($isStrictProperties &amp;&amp; $allowsDynamicProperties) {
        throw new Exception(&quot;A class may not have &#039;@strict-properties&#039; and &#039;#[\\AllowDynamicProperties]&#039; at the same time.&quot;);
    }

    $extends = [];
    $implements = [];

    if ($class instanceof Class_) {
        $classKind = &quot;class&quot;;
        if ($class-&gt;extends) {
            $extends[] = $class-&gt;extends;
        }
        $implements = $class-&gt;implements;
    } elseif ($class instanceof Interface_) {
        $classKind = &quot;interface&quot;;
        $extends = $class-&gt;extends;
    } else if ($class instanceof Trait_) {
        $classKind = &quot;trait&quot;;
    } else if ($class instanceof Enum_) {
        $classKind = &quot;enum&quot;;
        $implements = $class-&gt;implements;
    } else {
        throw new Exception(&quot;Unknown class kind &quot; . get_class($class));
    }

    if ($isUndocumentable) {
        foreach ($methods as $method) {
            $method-&gt;isUndocumentable = true;
        }
    }

    return new ClassInfo(
        $name,
        $flags,
        $classKind,
        $alias,
        $class instanceof Enum_ &amp;&amp; $class-&gt;scalarType !== null
            ? SimpleType::fromNode($class-&gt;scalarType) : null,
        $isDeprecated,
        $isStrictProperties,
        $attributes,
        createExposedDocComment($comments),
        $isNotSerializable,
        $extends,
        $implements,
        $consts,
        $properties,
        $methods,
        $enumCases,
        $cond,
        $minimumPhpVersionIdCompatibility,
        $isUndocumentable
    );
}

/**
 * @param array&lt;int, array&lt;int, AttributeGroup&gt;&gt; $attributeGroups
 * @return Attribute[]
 */
function createAttributes(array $attributeGroups): array {
    $attributes = [];

    foreach ($attributeGroups as $attrGroup) {
        foreach ($attrGroup-&gt;attrs as $attr) {
            $attributes[] = new AttributeInfo($attr-&gt;name-&gt;toString(), $attr-&gt;args);
        }
    }

    return $attributes;
}

/** @param array&lt;int, DocComment&gt; $comments */
function createExposedDocComment(array $comments): ?ExposedDocComment {
    $exposedDocComment = null;

    foreach ($comments as $comment) {
        $text = $comment-&gt;getText();
        $matches = [];
        $pattern = &quot;#^(\s*\/\*\*)(\s*@genstubs-expose-comment-block)(\s*)$#m&quot;;

        if (preg_match($pattern, $text, $matches) !== 1) {
            continue;
        }

        if ($exposedDocComment !== null) {
            throw new Exception(&quot;Only one PHPDoc comment block can be exposed&quot;);
        }

        $exposedDocComment = preg_replace($pattern, &#039;$1$3&#039;, $text);
    }

    return $exposedDocComment ? new ExposedDocComment($exposedDocComment) : null;
}

function handlePreprocessorConditions(array &amp;$conds, Stmt $stmt): ?string {
    foreach ($stmt-&gt;getComments() as $comment) {
        $text = trim($comment-&gt;getText());
        if (preg_match(&#039;/^#\s*if\s+(.+)$/&#039;, $text, $matches)) {
            $conds[] = $matches[1];
        } else if (preg_match(&#039;/^#\s*ifdef\s+(.+)$/&#039;, $text, $matches)) {
            $conds[] = &quot;defined($matches[1])&quot;;
        } else if (preg_match(&#039;/^#\s*ifndef\s+(.+)$/&#039;, $text, $matches)) {
            $conds[] = &quot;!defined($matches[1])&quot;;
        } else if (preg_match(&#039;/^#\s*else$/&#039;, $text)) {
            if (empty($conds)) {
                throw new Exception(&quot;Encountered else without corresponding #if&quot;);
            }
            $cond = array_pop($conds);
            $conds[] = &quot;!($cond)&quot;;
        } else if (preg_match(&#039;/^#\s*endif$/&#039;, $text)) {
            if (empty($conds)) {
                throw new Exception(&quot;Encountered #endif without corresponding #if&quot;);
            }
            array_pop($conds);
        } else if ($text[0] === &#039;#&#039;) {
            throw new Exception(&quot;Unrecognized preprocessor directive \&quot;$text\&quot;&quot;);
        }
    }

    return empty($conds) ? null : implode(&#039; &amp;&amp; &#039;, $conds);
}

/** @return DocComment[] */
function getFileDocComments(array $stmts): array {
    if (empty($stmts)) {
        return [];
    }

    $comments = $stmts[0]-&gt;getComments();

    $result = [];
    foreach ($comments as $comment) {
        if ($comment instanceof DocComment) {
            $result[] = $comment;
        }
    }

    return $result;
}

function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstract $prettyPrinter) {
    $conds = [];
    foreach ($stmts as $stmt) {
        $cond = handlePreprocessorConditions($conds, $stmt);

        if ($stmt instanceof Stmt\Nop) {
            continue;
        }

        if ($stmt instanceof Stmt\Namespace_) {
            handleStatements($fileInfo, $stmt-&gt;stmts, $prettyPrinter);
            continue;
        }

        if ($stmt instanceof Stmt\Const_) {
            foreach ($stmt-&gt;consts as $const) {
                $fileInfo-&gt;constInfos[] = parseConstLike(
                    $prettyPrinter,
                    new ConstName($const-&gt;namespacedName, $const-&gt;name-&gt;toString()),
                    $const,
                    0,
                    null,
                    $stmt-&gt;getComments(),
                    $cond,
                    $fileInfo-&gt;isUndocumentable,
                    $fileInfo-&gt;getMinimumPhpVersionIdCompatibility(),
                    []
                );
            }
            continue;
        }

        if ($stmt instanceof Stmt\Function_) {
            $fileInfo-&gt;funcInfos[] = parseFunctionLike(
                $prettyPrinter,
                new FunctionName($stmt-&gt;namespacedName),
                0,
                0,
                $stmt,
                $cond,
                $fileInfo-&gt;isUndocumentable,
                $fileInfo-&gt;getMinimumPhpVersionIdCompatibility()
            );
            continue;
        }

        if ($stmt instanceof Stmt\ClassLike) {
            $className = $stmt-&gt;namespacedName;
            $constInfos = [];
            $propertyInfos = [];
            $methodInfos = [];
            $enumCaseInfos = [];
            foreach ($stmt-&gt;stmts as $classStmt) {
                $cond = handlePreprocessorConditions($conds, $classStmt);
                if ($classStmt instanceof Stmt\Nop) {
                    continue;
                }

                $classFlags = $stmt instanceof Class_ ? $stmt-&gt;flags : 0;
                $abstractFlag = $stmt instanceof Stmt\Interface_ ? Modifiers::ABSTRACT : 0;

                if ($classStmt instanceof Stmt\ClassConst) {
                    foreach ($classStmt-&gt;consts as $const) {
                        $constInfos[] = parseConstLike(
                            $prettyPrinter,
                            new ClassConstName($className, $const-&gt;name-&gt;toString()),
                            $const,
                            $classStmt-&gt;flags,
                            $classStmt-&gt;type,
                            $classStmt-&gt;getComments(),
                            $cond,
                            $fileInfo-&gt;isUndocumentable,
                            $fileInfo-&gt;getMinimumPhpVersionIdCompatibility(),
                            createAttributes($classStmt-&gt;attrGroups)
                        );
                    }
                } else if ($classStmt instanceof Stmt\Property) {
                    if (!($classStmt-&gt;flags &amp; Class_::VISIBILITY_MODIFIER_MASK)) {
                        throw new Exception(&quot;Visibility modifier is required&quot;);
                    }
                    foreach ($classStmt-&gt;props as $property) {
                        $propertyInfos[] = parseProperty(
                            $className,
                            $classFlags,
                            $classStmt-&gt;flags,
                            $property,
                            $classStmt-&gt;type,
                            $classStmt-&gt;getComments(),
                            $prettyPrinter,
                            $fileInfo-&gt;getMinimumPhpVersionIdCompatibility(),
                            createAttributes($classStmt-&gt;attrGroups)
                        );
                    }
                } else if ($classStmt instanceof Stmt\ClassMethod) {
                    if (!($classStmt-&gt;flags &amp; Class_::VISIBILITY_MODIFIER_MASK)) {
                        throw new Exception(&quot;Visibility modifier is required&quot;);
                    }
                    $methodInfos[] = parseFunctionLike(
                        $prettyPrinter,
                        new MethodName($className, $classStmt-&gt;name-&gt;toString()),
                        $classFlags,
                        $classStmt-&gt;flags | $abstractFlag,
                        $classStmt,
                        $cond,
                        $fileInfo-&gt;isUndocumentable,
                        $fileInfo-&gt;getMinimumPhpVersionIdCompatibility()
                    );
                } else if ($classStmt instanceof Stmt\EnumCase) {
                    $enumCaseInfos[] = new EnumCaseInfo(
                        $classStmt-&gt;name-&gt;toString(), $classStmt-&gt;expr);
                } else {
                    throw new Exception(&quot;Not implemented {$classStmt-&gt;getType()}&quot;);
                }
            }

            $fileInfo-&gt;classInfos[] = parseClass(
                $className, $stmt, $constInfos, $propertyInfos, $methodInfos, $enumCaseInfos, $cond, $fileInfo-&gt;getMinimumPhpVersionIdCompatibility(), $fileInfo-&gt;isUndocumentable
            );
            continue;
        }

        if ($stmt instanceof Stmt\Expression) {
            $expr = $stmt-&gt;expr;
            if ($expr instanceof Expr\Include_) {
                $fileInfo-&gt;dependencies[] = (string)EvaluatedValue::createFromExpression($expr-&gt;expr, null, null, [])-&gt;value;
                continue;
            }
        }

        throw new Exception(&quot;Unexpected node {$stmt-&gt;getType()}&quot;);
    }
    if (!empty($conds)) {
        throw new Exception(&quot;Unterminated preprocessor conditions&quot;);
    }
}

function parseStubFile(string $code): FileInfo {
    $lexer = new PhpParser\Lexer\Emulative();
    $parser = new PhpParser\Parser\Php7($lexer);
    $nodeTraverser = new PhpParser\NodeTraverser;
    $nodeTraverser-&gt;addVisitor(new PhpParser\NodeVisitor\NameResolver);
    $prettyPrinter = new class extends Standard {
        protected function pName_FullyQualified(Name\FullyQualified $node): string {
            return implode(&#039;\\&#039;, $node-&gt;getParts());
        }
    };

    $stmts = $parser-&gt;parse($code);
    $nodeTraverser-&gt;traverse($stmts);

    $fileInfo = new FileInfo;
    $fileDocComments = getFileDocComments($stmts);
    if ($fileDocComments !== []) {
        $fileTags = parseDocComments($fileDocComments);
        foreach ($fileTags as $tag) {
            if ($tag-&gt;name === &#039;generate-function-entries&#039;) {
                $fileInfo-&gt;generateFunctionEntries = true;
                $fileInfo-&gt;declarationPrefix = $tag-&gt;value ? $tag-&gt;value . &quot; &quot; : &quot;&quot;;
            } else if ($tag-&gt;name === &#039;generate-legacy-arginfo&#039;) {
                if ($tag-&gt;value &amp;&amp; !in_array((int) $tag-&gt;value, ALL_PHP_VERSION_IDS, true)) {
                    throw new Exception(
                        &quot;Legacy PHP version must be one of: \&quot;&quot; . PHP_70_VERSION_ID . &quot;\&quot; (PHP 7.0), \&quot;&quot; . PHP_80_VERSION_ID . &quot;\&quot; (PHP 8.0), &quot; .
                        &quot;\&quot;&quot; . PHP_81_VERSION_ID . &quot;\&quot; (PHP 8.1), \&quot;&quot; . PHP_82_VERSION_ID . &quot;\&quot; (PHP 8.2), \&quot;&quot; . PHP_83_VERSION_ID . &quot;\&quot; (PHP 8.3), &quot; .
                        &quot;\&quot;&quot; . PHP_84_VERSION_ID . &quot;\&quot; (PHP 8.4), \&quot;&quot; . $tag-&gt;value . &quot;\&quot; provided&quot;
                    );
                }

                $fileInfo-&gt;setMinimumPhpVersionIdCompatibility($tag-&gt;value ? (int) $tag-&gt;value : PHP_70_VERSION_ID);
            } else if ($tag-&gt;name === &#039;generate-class-entries&#039;) {
                $fileInfo-&gt;generateClassEntries = true;
                $fileInfo-&gt;declarationPrefix = $tag-&gt;value ? $tag-&gt;value . &quot; &quot; : &quot;&quot;;
            } else if ($tag-&gt;name === &#039;undocumentable&#039;) {
                $fileInfo-&gt;isUndocumentable = true;
            }
        }
    }

    // Generating class entries require generating function/method entries
    if ($fileInfo-&gt;generateClassEntries &amp;&amp; !$fileInfo-&gt;generateFunctionEntries) {
        $fileInfo-&gt;generateFunctionEntries = true;
    }

    handleStatements($fileInfo, $stmts, $prettyPrinter);
    return $fileInfo;
}

function funcInfoToCode(FileInfo $fileInfo, FuncInfo $funcInfo): string {
    $code = &#039;&#039;;
    $returnType = $funcInfo-&gt;return-&gt;type;
    $isTentativeReturnType = $funcInfo-&gt;return-&gt;tentativeReturnType;
    $php81MinimumCompatibility = $fileInfo-&gt;getMinimumPhpVersionIdCompatibility() === null || $fileInfo-&gt;getMinimumPhpVersionIdCompatibility() &gt;= PHP_81_VERSION_ID;

    if ($returnType !== null) {
        if ($isTentativeReturnType &amp;&amp; !$php81MinimumCompatibility) {
            $code .= &quot;#if (PHP_VERSION_ID &gt;= &quot; . PHP_81_VERSION_ID . &quot;)\n&quot;;
        }
        if (null !== $simpleReturnType = $returnType-&gt;tryToSimpleType()) {
            if ($simpleReturnType-&gt;isBuiltin) {
                $code .= sprintf(
                    &quot;%s(%s, %d, %d, %s, %d)\n&quot;,
                    $isTentativeReturnType ? &quot;ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX&quot; : &quot;ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $simpleReturnType-&gt;toTypeCode(), $returnType-&gt;isNullable()
                );
            } else {
                $code .= sprintf(
                    &quot;%s(%s, %d, %d, %s, %d)\n&quot;,
                    $isTentativeReturnType ? &quot;ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX&quot; : &quot;ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $simpleReturnType-&gt;toEscapedName(), $returnType-&gt;isNullable()
                );
            }
        } else {
            $arginfoType = $returnType-&gt;toArginfoType();
            if ($arginfoType-&gt;hasClassType()) {
                $code .= sprintf(
                    &quot;%s(%s, %d, %d, %s, %s)\n&quot;,
                    $isTentativeReturnType ? &quot;ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_TYPE_MASK_EX&quot; : &quot;ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $arginfoType-&gt;toClassTypeString(), $arginfoType-&gt;toTypeMask()
                );
            } else {
                $code .= sprintf(
                    &quot;%s(%s, %d, %d, %s)\n&quot;,
                    $isTentativeReturnType ? &quot;ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_MASK_EX&quot; : &quot;ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $arginfoType-&gt;toTypeMask()
                );
            }
        }
        if ($isTentativeReturnType &amp;&amp; !$php81MinimumCompatibility) {
            $code .= sprintf(
                &quot;#else\nZEND_BEGIN_ARG_INFO_EX(%s, 0, %d, %d)\n#endif\n&quot;,
                $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef, $funcInfo-&gt;numRequiredArgs
            );
        }
    } else {
        $code .= sprintf(
            &quot;ZEND_BEGIN_ARG_INFO_EX(%s, 0, %d, %d)\n&quot;,
            $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef, $funcInfo-&gt;numRequiredArgs
        );
    }

    foreach ($funcInfo-&gt;args as $argInfo) {
        $argKind = $argInfo-&gt;isVariadic ? &quot;ARG_VARIADIC&quot; : &quot;ARG&quot;;
        $argDefaultKind = $argInfo-&gt;hasProperDefaultValue() ? &quot;_WITH_DEFAULT_VALUE&quot; : &quot;&quot;;
        $argType = $argInfo-&gt;type;
        if ($argType !== null) {
            if (null !== $simpleArgType = $argType-&gt;tryToSimpleType()) {
                if ($simpleArgType-&gt;isBuiltin) {
                    $code .= sprintf(
                        &quot;\tZEND_%s_TYPE_INFO%s(%s, %s, %s, %d%s)\n&quot;,
                        $argKind, $argDefaultKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $simpleArgType-&gt;toTypeCode(), $argType-&gt;isNullable(),
                        $argInfo-&gt;hasProperDefaultValue() ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
                    );
                } else {
                    $code .= sprintf(
                        &quot;\tZEND_%s_OBJ_INFO%s(%s, %s, %s, %d%s)\n&quot;,
                        $argKind,$argDefaultKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $simpleArgType-&gt;toEscapedName(), $argType-&gt;isNullable(),
                        $argInfo-&gt;hasProperDefaultValue() ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
                    );
                }
            } else {
                $arginfoType = $argType-&gt;toArginfoType();
                if ($arginfoType-&gt;hasClassType()) {
                    $code .= sprintf(
                        &quot;\tZEND_%s_OBJ_TYPE_MASK(%s, %s, %s, %s%s)\n&quot;,
                        $argKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $arginfoType-&gt;toClassTypeString(), $arginfoType-&gt;toTypeMask(),
                        !$argInfo-&gt;isVariadic ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
                    );
                } else {
                    $code .= sprintf(
                        &quot;\tZEND_%s_TYPE_MASK(%s, %s, %s, %s)\n&quot;,
                        $argKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $arginfoType-&gt;toTypeMask(),
                        $argInfo-&gt;getDefaultValueAsArginfoString()
                    );
                }
            }
        } else {
            $code .= sprintf(
                &quot;\tZEND_%s_INFO%s(%s, %s%s)\n&quot;,
                $argKind, $argDefaultKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                $argInfo-&gt;hasProperDefaultValue() ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
            );
        }
    }

    $code .= &quot;ZEND_END_ARG_INFO()&quot;;
    return $code . &quot;\n&quot;;
}

/** @param FuncInfo[] $generatedFuncInfos */
function findEquivalentFuncInfo(array $generatedFuncInfos, FuncInfo $funcInfo): ?FuncInfo {
    foreach ($generatedFuncInfos as $generatedFuncInfo) {
        if ($generatedFuncInfo-&gt;equalsApartFromNameAndRefcount($funcInfo)) {
            return $generatedFuncInfo;
        }
    }
    return null;
}

/**
 * @template T
 * @param iterable&lt;T&gt; $infos
 * @param Closure(T): string|null $codeGenerator
 * @param ?string $parentCond
 */
function generateCodeWithConditions(
    iterable $infos, string $separator, Closure $codeGenerator, ?string $parentCond = null): string {
    $code = &quot;&quot;;
    
    // For combining the conditional blocks of the infos with the same condition
    $openCondition = null;
    foreach ($infos as $info) {
        $infoCode = $codeGenerator($info);
        if ($infoCode === null) {
            continue;
        }

        if ($info-&gt;cond &amp;&amp; $info-&gt;cond !== $parentCond) {
            if ($openCondition !== null
                &amp;&amp; $info-&gt;cond !== $openCondition
            ) {
                // Changing condition, end old
                $code .= &quot;#endif\n&quot;;
                $code .= $separator;
                $code .= &quot;#if {$info-&gt;cond}\n&quot;;
                $openCondition = $info-&gt;cond;
            } elseif ($openCondition === null) {
                // New condition with no existing one
                $code .= $separator;
                $code .= &quot;#if {$info-&gt;cond}\n&quot;;
                $openCondition = $info-&gt;cond;
            } else {
                // Staying in the same condition
                $code .= $separator;
            }
            $code .= $infoCode;
        } else {
            if ($openCondition !== null) {
                // Ending the condition
                $code .= &quot;#endif\n&quot;;
                $openCondition = null;
            }
            $code .= $separator;
            $code .= $infoCode;
        }
    }
    // The last info might have been in a conditional block
    if ($openCondition !== null) {
        $code .= &quot;#endif\n&quot;;
    }

    return $code;
}

/**
 * @param array&lt;string, ConstInfo&gt; $allConstInfos
 */
function generateArgInfoCode(
    string $stubFilenameWithoutExtension,
    FileInfo $fileInfo,
    array $allConstInfos,
    string $stubHash
): string {
    $code = &quot;/* This is a generated file, edit the .stub.php file instead.\n&quot;
          . &quot; * Stub hash: $stubHash */\n&quot;;

    $generatedFuncInfos = [];

    $argInfoCode = generateCodeWithConditions(
        $fileInfo-&gt;getAllFuncInfos(), &quot;\n&quot;,
        static function (FuncInfo $funcInfo) use (&amp;$generatedFuncInfos, $fileInfo) {
            /* If there already is an equivalent arginfo structure, only emit a #define */
            if ($generatedFuncInfo = findEquivalentFuncInfo($generatedFuncInfos, $funcInfo)) {
                $code = sprintf(
                    &quot;#define %s %s\n&quot;,
                    $funcInfo-&gt;getArgInfoName(), $generatedFuncInfo-&gt;getArgInfoName()
                );
            } else {
                $code = funcInfoToCode($fileInfo, $funcInfo);
            }

            $generatedFuncInfos[] = $funcInfo;
            return $code;
        }
    );

    if ($argInfoCode !== &quot;&quot;) {
        $code .= &quot;$argInfoCode\n&quot;;
    }

    if ($fileInfo-&gt;generateFunctionEntries) {
        $framelessFunctionCode = generateCodeWithConditions(
            $fileInfo-&gt;getAllFuncInfos(), &quot;\n&quot;,
            static function (FuncInfo $funcInfo) {
                $code = $funcInfo-&gt;getFramelessDeclaration($funcInfo);
                return $code;
            }
        );

        if ($framelessFunctionCode !== &quot;&quot;) {
            $code .= &quot;$framelessFunctionCode\n&quot;;
        }

        $generatedFunctionDeclarations = [];
        $code .= generateCodeWithConditions(
            $fileInfo-&gt;getAllFuncInfos(), &quot;&quot;,
            static function (FuncInfo $funcInfo) use ($fileInfo, &amp;$generatedFunctionDeclarations) {
                $key = $funcInfo-&gt;getDeclarationKey();
                if (isset($generatedFunctionDeclarations[$key])) {
                    return null;
                }

                $generatedFunctionDeclarations[$key] = true;
                return $fileInfo-&gt;declarationPrefix . $funcInfo-&gt;getDeclaration();
            }
        );

        $code .= generateFunctionEntries(null, $fileInfo-&gt;funcInfos);

        foreach ($fileInfo-&gt;classInfos as $classInfo) {
            $code .= generateFunctionEntries($classInfo-&gt;name, $classInfo-&gt;funcInfos, $classInfo-&gt;cond);
        }
    }

    $php80MinimumCompatibility = $fileInfo-&gt;getMinimumPhpVersionIdCompatibility() === null || $fileInfo-&gt;getMinimumPhpVersionIdCompatibility() &gt;= PHP_80_VERSION_ID;

    if ($fileInfo-&gt;generateClassEntries) {
        if ($attributeInitializationCode = generateFunctionAttributeInitialization($fileInfo-&gt;funcInfos, $allConstInfos, $fileInfo-&gt;getMinimumPhpVersionIdCompatibility(), null)) {
            if (!$php80MinimumCompatibility) {
                $attributeInitializationCode = &quot;\n#if (PHP_VERSION_ID &gt;= &quot; . PHP_80_VERSION_ID . &quot;)&quot; . $attributeInitializationCode . &quot;#endif\n&quot;;
            }
        }

        if ($attributeInitializationCode !== &quot;&quot; || !empty($fileInfo-&gt;constInfos)) {
            $code .= &quot;\nstatic void register_{$stubFilenameWithoutExtension}_symbols(int module_number)\n&quot;;
            $code .= &quot;{\n&quot;;

            foreach ($fileInfo-&gt;constInfos as $constInfo) {
                $code .= $constInfo-&gt;getDeclaration($allConstInfos);
            }

            if ($attributeInitializationCode !== &quot;&quot; &amp;&amp; $fileInfo-&gt;constInfos) {
                $code .= &quot;\n&quot;;
            }

            $code .= $attributeInitializationCode;
            $code .= &quot;}\n&quot;;
        }

        $code .= generateClassEntryCode($fileInfo, $allConstInfos);
    }

    return $code;
}

/** @param array&lt;string, ConstInfo&gt; $allConstInfos */
function generateClassEntryCode(FileInfo $fileInfo, array $allConstInfos): string {
    $code = &quot;&quot;;

    foreach ($fileInfo-&gt;classInfos as $class) {
        $code .= &quot;\n&quot; . $class-&gt;getRegistration($allConstInfos);
    }

    return $code;
}

/** @param FuncInfo[] $funcInfos */
function generateFunctionEntries(?Name $className, array $funcInfos, ?string $cond = null): string {
    // No need to add anything if there are no function entries
    if ($funcInfos === []) {
        return &#039;&#039;;
    }

    $code = &quot;\n&quot;;

    if ($cond) {
        $code .= &quot;#if {$cond}\n&quot;;
    }

    $functionEntryName = &quot;ext_functions&quot;;
    if ($className) {
        $underscoreName = implode(&quot;_&quot;, $className-&gt;getParts());
        $functionEntryName = &quot;class_{$underscoreName}_methods&quot;;
    }

    $code .= &quot;static const zend_function_entry {$functionEntryName}[] = {\n&quot;;
    $code .= generateCodeWithConditions($funcInfos, &quot;&quot;, static function (FuncInfo $funcInfo) {
        return $funcInfo-&gt;getFunctionEntry();
    }, $cond);
    $code .= &quot;\tZEND_FE_END\n&quot;;
    $code .= &quot;};\n&quot;;

    if ($cond) {
        $code .= &quot;#endif\n&quot;;
    }

    return $code;
}

/** @param iterable&lt;FuncInfo&gt; $funcInfos */
function generateFunctionAttributeInitialization(iterable $funcInfos, array $allConstInfos, ?int $phpVersionIdMinimumCompatibility, ?string $parentCond = null): string {
    return generateCodeWithConditions(
        $funcInfos,
        &quot;&quot;,
        static function (FuncInfo $funcInfo) use ($allConstInfos, $phpVersionIdMinimumCompatibility) {
            $code = null;

            if ($funcInfo-&gt;name instanceof MethodName) {
                $functionTable = &quot;&amp;class_entry-&gt;function_table&quot;;
            } else {
                $functionTable = &quot;CG(function_table)&quot;;
            }

            foreach ($funcInfo-&gt;attributes as $key =&gt; $attribute) {
                $code .= $attribute-&gt;generateCode(
                    &quot;zend_add_function_attribute(zend_hash_str_find_ptr($functionTable, \&quot;&quot; . $funcInfo-&gt;name-&gt;getNameForAttributes() . &quot;\&quot;, sizeof(\&quot;&quot; . $funcInfo-&gt;name-&gt;getNameForAttributes() . &quot;\&quot;) - 1)&quot;,
                    &quot;func_&quot; . $funcInfo-&gt;name-&gt;getNameForAttributes() . &quot;_$key&quot;,
                    $allConstInfos,
                    $phpVersionIdMinimumCompatibility
                );
            }

            foreach ($funcInfo-&gt;args as $index =&gt; $arg) {
                foreach ($arg-&gt;attributes as $key =&gt; $attribute) {
                    $code .= $attribute-&gt;generateCode(
                        &quot;zend_add_parameter_attribute(zend_hash_str_find_ptr($functionTable, \&quot;&quot; . $funcInfo-&gt;name-&gt;getNameForAttributes() . &quot;\&quot;, sizeof(\&quot;&quot; . $funcInfo-&gt;name-&gt;getNameForAttributes() . &quot;\&quot;) - 1), $index&quot;,
                        &quot;func_{$funcInfo-&gt;name-&gt;getNameForAttributes()}_arg{$index}_$key&quot;,
                        $allConstInfos,
                        $phpVersionIdMinimumCompatibility
                    );
                }
            }

            return $code;
        },
        $parentCond
    );
}

/**
 * @param iterable&lt;ConstInfo&gt; $constInfos
 * @param array&lt;string, ConstInfo&gt; $allConstInfos
 */
function generateConstantAttributeInitialization(
    iterable $constInfos,
    array $allConstInfos,
    ?int $phpVersionIdMinimumCompatibility,
    ?string $parentCond = null
): string {
    return generateCodeWithConditions(
        $constInfos,
        &quot;&quot;,
        static function (ConstInfo $constInfo) use ($allConstInfos, $phpVersionIdMinimumCompatibility) {
            $code = null;

            foreach ($constInfo-&gt;attributes as $key =&gt; $attribute) {
                $code .= $attribute-&gt;generateCode(
                    &quot;zend_add_class_constant_attribute(class_entry, const_&quot; . $constInfo-&gt;name-&gt;getDeclarationName(),
                    &quot;const_&quot; . $constInfo-&gt;name-&gt;getDeclarationName() . &quot;_$key&quot;,
                    $allConstInfos,
                    $phpVersionIdMinimumCompatibility
                );
            }

            return $code;
        },
        $parentCond
    );
}

/**
 * @param iterable&lt;PropertyInfo&gt; $propertyInfos
 * @param array&lt;string, ConstInfo&gt; $allConstInfos
 */
function generatePropertyAttributeInitialization(
    iterable $propertyInfos,
    array $allConstInfos,
    ?int $phpVersionIdMinimumCompatibility
): string {
    $code = &quot;&quot;;
    foreach ($propertyInfos as $propertyInfo) {
        foreach ($propertyInfo-&gt;attributes as $key =&gt; $attribute) {
            $code .= $attribute-&gt;generateCode(
                &quot;zend_add_property_attribute(class_entry, property_&quot; . $propertyInfo-&gt;name-&gt;getDeclarationName(),
                &quot;property_&quot; . $propertyInfo-&gt;name-&gt;getDeclarationName() . &quot;_&quot; . $key,
                $allConstInfos,
                $phpVersionIdMinimumCompatibility
            );
        }
    }

    return $code;
}

/** @param array&lt;string, FuncInfo&gt; $funcMap */
function generateOptimizerInfo(array $funcMap): string {

    $code = &quot;/* This is a generated file, edit the .stub.php files instead. */\n\n&quot;;

    $code .= &quot;static const func_info_t func_infos[] = {\n&quot;;

    $code .= generateCodeWithConditions($funcMap, &quot;&quot;, static function (FuncInfo $funcInfo) {
        return $funcInfo-&gt;getOptimizerInfo();
    });

    $code .= &quot;};\n&quot;;

    return $code;
}

/**
 * @param array&lt;int, string[]&gt; $flagsByPhpVersions
 * @return string[]
 */
function generateVersionDependentFlagCode(string $codeTemplate, array $flagsByPhpVersions, ?int $phpVersionIdMinimumCompatibility): array
{
    $phpVersions = ALL_PHP_VERSION_IDS;
    sort($phpVersions);
    $currentPhpVersion = end($phpVersions);

    // No version compatibility is needed
    if ($phpVersionIdMinimumCompatibility === null) {
        if (empty($flagsByPhpVersions[$currentPhpVersion])) {
            return [];
        }

        return [sprintf($codeTemplate, implode(&quot;|&quot;, $flagsByPhpVersions[$currentPhpVersion]))];
    }

    // Remove flags which depend on a PHP version below the minimally supported one
    ksort($flagsByPhpVersions);
    $index = array_search($phpVersionIdMinimumCompatibility, array_keys($flagsByPhpVersions));
    if ($index === false) {
        throw new Exception(&quot;Missing version dependent flags for PHP version ID \&quot;$phpVersionIdMinimumCompatibility\&quot;&quot;);
    }
    $flagsByPhpVersions = array_slice($flagsByPhpVersions, $index, null, true);

    // Remove empty version-specific flags
    $flagsByPhpVersions = array_filter(
        $flagsByPhpVersions,
        static function (array $value): bool {
            return !empty($value);
    });

    // There are no version-specific flags
    if (empty($flagsByPhpVersions)) {
        return [];
    }

    // Remove version-specific flags which don&#039;t differ from the previous one
    $previousVersionId = null;
    foreach ($flagsByPhpVersions as $versionId =&gt; $versionFlags) {
        if ($previousVersionId !== null &amp;&amp; $flagsByPhpVersions[$previousVersionId] === $versionFlags) {
            unset($flagsByPhpVersions[$versionId]);
        } else {
            $previousVersionId = $versionId;
        }
    }

    $flagCount = count($flagsByPhpVersions);

    // Do not add a condition unnecessarily when the only version is the same as the minimally supported one
    if ($flagCount === 1) {
        reset($flagsByPhpVersions);
        $firstVersion = key($flagsByPhpVersions);
        if ($firstVersion === $phpVersionIdMinimumCompatibility) {
            return [sprintf($codeTemplate, implode(&quot;|&quot;, reset($flagsByPhpVersions)))];
        }
    }

    // Add the necessary conditions around the code using the version-specific flags
    $result = [];
    $i = 0;
    foreach (array_reverse($flagsByPhpVersions, true) as $version =&gt; $versionFlags) {
        $code = &quot;&quot;;

        $if = $i === 0 ? &quot;#if&quot; : &quot;#elif&quot;;
        $endif = $i === $flagCount - 1 ? &quot;#endif\n&quot; : &quot;&quot;;

        $code .= &quot;$if (PHP_VERSION_ID &gt;= $version)\n&quot;;

        $code .= sprintf($codeTemplate, implode(&quot;|&quot;, $versionFlags));
        $code .= $endif;

        $result[] = $code;
        $i++;
    }

    return $result;
}

/**
 * @param array&lt;string, ConstInfo&gt; $constMap
 * @param array&lt;string, ConstInfo&gt; $undocumentedConstMap
 * @return array&lt;string, string|null&gt;
 */
function replacePredefinedConstants(string $targetDirectory, array $constMap, array &amp;$undocumentedConstMap): array {
    /** @var array&lt;string, string&gt; $documentedConstMap */
    $documentedConstMap = [];
    /** @var array&lt;string, string&gt; $predefinedConstants */
    $predefinedConstants = [];

    $it = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($targetDirectory),
        RecursiveIteratorIterator::LEAVES_ONLY
    );

    foreach ($it as $file) {
        $pathName = $file-&gt;getPathName();
        if (!preg_match(&#039;/(?:[\w\.]*constants[\w\._]*|tokens).xml$/i&#039;, basename($pathName))) {
            continue;
        }

        $xml = file_get_contents($pathName);
        if ($xml === false) {
            continue;
        }

        if (stripos($xml, &quot;&lt;appendix&quot;) === false &amp;&amp; stripos($xml, &quot;&lt;sect2&quot;) === false &amp;&amp;
            stripos($xml, &quot;&lt;chapter&quot;) === false &amp;&amp; stripos($xml, &#039;role=&quot;constant_list&quot;&#039;) === false
        ) {
            continue;
        }

        $replacedXml = getReplacedSynopsisXml($xml);

        $doc = new DOMDocument();
        $doc-&gt;formatOutput = false;
        $doc-&gt;preserveWhiteSpace = true;
        $doc-&gt;validateOnParse = true;
        $success = $doc-&gt;loadXML($replacedXml);
        if (!$success) {
            echo &quot;Failed opening $pathName\n&quot;;
            continue;
        }

        $updated = false;

        foreach ($doc-&gt;getElementsByTagName(&quot;varlistentry&quot;) as $entry) {
            if (!$entry instanceof DOMElement) {
                continue;
            }

            foreach ($entry-&gt;getElementsByTagName(&quot;term&quot;) as $manualTermElement) {
                $manualConstantElement = $manualTermElement-&gt;getElementsByTagName(&quot;constant&quot;)-&gt;item(0);
                if (!$manualConstantElement instanceof DOMElement) {
                    continue;
                }

                $manualConstantName = $manualConstantElement-&gt;textContent;

                $stubConstant = $constMap[$manualConstantName] ?? null;
                if ($stubConstant === null) {
                    continue;
                }

                $documentedConstMap[$manualConstantName] = $manualConstantName;

                if ($entry-&gt;firstChild instanceof DOMText) {
                    $indentationLevel = strlen(str_replace(&quot;\n&quot;, &quot;&quot;, $entry-&gt;firstChild-&gt;textContent));
                } else {
                    $indentationLevel = 3;
                }
                $newTermElement = $stubConstant-&gt;getPredefinedConstantTerm($doc, $indentationLevel);

                if ($manualTermElement-&gt;textContent === $newTermElement-&gt;textContent) {
                    continue;
                }

                $manualTermElement-&gt;parentNode-&gt;replaceChild($newTermElement, $manualTermElement);
                $updated = true;
            }
        }

        foreach ($doc-&gt;getElementsByTagName(&quot;row&quot;) as $row) {
            if (!$row instanceof DOMElement) {
                continue;
            }

            $entry = $row-&gt;getElementsByTagName(&quot;entry&quot;)-&gt;item(0);
            if (!$entry instanceof DOMElement) {
                continue;
            }

            foreach ($entry-&gt;getElementsByTagName(&quot;constant&quot;) as $manualConstantElement) {
                if (!$manualConstantElement instanceof DOMElement) {
                    continue;
                }

                $manualConstantName = $manualConstantElement-&gt;textContent;

                $stubConstant = $constMap[$manualConstantName] ?? null;
                if ($stubConstant === null) {
                    continue;
                }

                $documentedConstMap[$manualConstantName] = $manualConstantName;

                if ($row-&gt;firstChild instanceof DOMText) {
                    $indentationLevel = strlen(str_replace(&quot;\n&quot;, &quot;&quot;, $row-&gt;firstChild-&gt;textContent));
                } else {
                    $indentationLevel = 3;
                }
                $newEntryElement = $stubConstant-&gt;getPredefinedConstantEntry($doc, $indentationLevel);

                if ($entry-&gt;textContent === $newEntryElement-&gt;textContent) {
                    continue;
                }

                $entry-&gt;parentNode-&gt;replaceChild($newEntryElement, $entry);
                $updated = true;
            }
        }

        if ($updated) {
            $replacedXml = $doc-&gt;saveXML();

            $replacedXml = preg_replace(
                [
                    &quot;/REPLACED-ENTITY-([A-Za-z0-9._{}%-]+?;)/&quot;,
                    &#039;/&lt;appendix\s+xmlns=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;appendix\s+xmlns=&quot;([^&quot;]+)&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;sect2\s+xmlns=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;sect2\s+xmlns=&quot;([^&quot;]+)&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;chapter\s+xmlns=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;chapter\s+xmlns=&quot;([^&quot;]+)&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                ],
                [
                    &quot;&amp;$1&quot;,
                    &quot;&lt;appendix xml:id=\&quot;$2\&quot; xmlns=\&quot;$1\&quot;&gt;&quot;,
                    &quot;&lt;appendix xml:id=\&quot;$3\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot;&gt;&quot;,
                    &quot;&lt;sect2 xml:id=\&quot;$2\&quot; xmlns=\&quot;$1\&quot;&gt;&quot;,
                    &quot;&lt;sect2 xml:id=\&quot;$3\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot;&gt;&quot;,
                    &quot;&lt;chapter xml:id=\&quot;$2\&quot; xmlns=\&quot;$1\&quot;&gt;&quot;,
                    &quot;&lt;chapter xml:id=\&quot;$3\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot;&gt;&quot;,
                ],
                $replacedXml
            );

            $predefinedConstants[$pathName] = $replacedXml;
        }
    }

    $undocumentedConstMap = array_diff_key($constMap, $documentedConstMap);

    return $predefinedConstants;
}

/**
 * @param array&lt;string, ClassInfo&gt; $classMap
 * @param array&lt;string, ConstInfo&gt; $allConstInfos
 * @return array&lt;string, string&gt;
 */
function generateClassSynopses(array $classMap, array $allConstInfos): array {
    $result = [];

    foreach ($classMap as $classInfo) {
        $classSynopsis = $classInfo-&gt;getClassSynopsisDocument($classMap, $allConstInfos);
        if ($classSynopsis !== null) {
            $result[ClassInfo::getClassSynopsisFilename($classInfo-&gt;name) . &quot;.xml&quot;] = $classSynopsis;
        }
    }

    return $result;
}

/**
 * @param array&lt;string, ClassInfo&gt; $classMap
 * @param array&lt;string, ConstInfo&gt; $allConstInfos
 * @param array&lt;string, ClassInfo&gt; $undocumentedClassMap
 * @return array&lt;string, string&gt;
 */
function replaceClassSynopses(
    string $targetDirectory,
    array $classMap,
    array $allConstInfos,
    array &amp;$undocumentedClassMap
): array {
    /** @var array&lt;string, string&gt; $documentedClassMap */
    $documentedClassMap = [];
    /** @var array&lt;string, string&gt; $classSynopses */
    $classSynopses = [];

    $it = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($targetDirectory),
        RecursiveIteratorIterator::LEAVES_ONLY
    );

    foreach ($it as $file) {
        $pathName = $file-&gt;getPathName();
        if (!preg_match(&#039;/\.xml$/i&#039;, $pathName)) {
            continue;
        }

        $xml = file_get_contents($pathName);
        if ($xml === false) {
            continue;
        }

        if (stripos($xml, &quot;&lt;classsynopsis&quot;) === false) {
            continue;
        }

        $replacedXml = getReplacedSynopsisXml($xml);

        $doc = new DOMDocument();
        $doc-&gt;formatOutput = false;
        $doc-&gt;preserveWhiteSpace = true;
        $doc-&gt;validateOnParse = true;
        $success = $doc-&gt;loadXML($replacedXml);
        if (!$success) {
            echo &quot;Failed opening $pathName\n&quot;;
            continue;
        }

        $classSynopsisElements = [];
        foreach ($doc-&gt;getElementsByTagName(&quot;classsynopsis&quot;) as $element) {
            $classSynopsisElements[] = $element;
        }

        foreach ($classSynopsisElements as $classSynopsis) {
            if (!$classSynopsis instanceof DOMElement) {
                continue;
            }

            $child = $classSynopsis-&gt;firstElementChild;
            if ($child === null) {
                continue;
            }
            $child = $child-&gt;lastElementChild;
            if ($child === null) {
                continue;
            }
            $className = $child-&gt;textContent;
            if (!isset($classMap[$className])) {
                continue;
            }

            $documentedClassMap[$className] = $className;

            $classInfo = $classMap[$className];

            $newClassSynopsis = $classInfo-&gt;getClassSynopsisElement($doc, $classMap, $allConstInfos);
            if ($newClassSynopsis === null) {
                continue;
            }

            // Check if there is any change - short circuit if there is not any.

            if (replaceAndCompareXmls($doc, $classSynopsis, $newClassSynopsis)) {
                continue;
            }

            // Return the updated XML

            $replacedXml = $doc-&gt;saveXML();

            $replacedXml = preg_replace(
                [
                    &quot;/REPLACED-ENTITY-([A-Za-z0-9._{}%-]+?;)/&quot;,
                    &#039;/&lt;reference\s+role=&quot;(\w+)&quot;\s+xmlns=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;reference\s+role=&quot;(\w+)&quot;\s+xmlns=&quot;([^&quot;]+)&quot;\s+xmlns:xi=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;reference\s+role=&quot;(\w+)&quot;\s+xmlns=&quot;([^&quot;]+)&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xmlns:xi=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;reference\s+role=&quot;(\w+)&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xmlns:xi=&quot;([^&quot;]+)&quot;\s+xmlns=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;reference\s+xmlns=\&quot;([^&quot;]+)\&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xmlns:xi=&quot;([^&quot;]+)&quot;\s+role=&quot;(\w+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;reference\s+xmlns=\&quot;([^&quot;]+)\&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xmlns:xi=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s+role=&quot;(\w+)&quot;\s*&gt;/i&#039;,
                ],
                [
                    &quot;&amp;$1&quot;,
                    &quot;&lt;reference xml:id=\&quot;$3\&quot; role=\&quot;$1\&quot; xmlns=\&quot;$2\&quot;&gt;&quot;,
                    &quot;&lt;reference xml:id=\&quot;$4\&quot; role=\&quot;$1\&quot; xmlns=\&quot;$2\&quot; xmlns:xi=\&quot;$3\&quot;&gt;&quot;,
                    &quot;&lt;reference xml:id=\&quot;$5\&quot; role=\&quot;$1\&quot; xmlns=\&quot;$2\&quot; xmlns:xlink=\&quot;$3\&quot; xmlns:xi=\&quot;$4\&quot;&gt;&quot;,
                    &quot;&lt;reference xml:id=\&quot;$5\&quot; role=\&quot;$1\&quot; xmlns=\&quot;$4\&quot; xmlns:xlink=\&quot;$2\&quot; xmlns:xi=\&quot;$2\&quot;&gt;&quot;,
                    &quot;&lt;reference xml:id=\&quot;$5\&quot; role=\&quot;$4\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot; xmlns:xi=\&quot;$3\&quot;&gt;&quot;,
                    &quot;&lt;reference xml:id=\&quot;$4\&quot; role=\&quot;$5\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot; xmlns:xi=\&quot;$3\&quot;&gt;&quot;,
                ],
                $replacedXml
            );

            $classSynopses[$pathName] = $replacedXml;
        }
    }

    $undocumentedClassMap = array_diff_key($classMap, $documentedClassMap);

    return $classSynopses;
}

function getReplacedSynopsisXml(string $xml): string
{
    return preg_replace(
        [
            &quot;/&amp;([A-Za-z0-9._{}%-]+?;)/&quot;,
            &quot;/&lt;(\/)*xi:([A-Za-z]+?)/&quot;
        ],
        [
            &quot;REPLACED-ENTITY-$1&quot;,
            &quot;&lt;$1XI$2&quot;,
        ],
        $xml
    );
}

/**
 * @param array&lt;string, FuncInfo&gt; $funcMap
 * @param array&lt;string, FuncInfo&gt; $aliasMap
 * @return array&lt;string, string&gt;
 */
function generateMethodSynopses(array $funcMap, array $aliasMap): array {
    $result = [];

    foreach ($funcMap as $funcInfo) {
        $methodSynopsis = $funcInfo-&gt;getMethodSynopsisDocument($funcMap, $aliasMap);
        if ($methodSynopsis !== null) {
            $result[$funcInfo-&gt;name-&gt;getMethodSynopsisFilename() . &quot;.xml&quot;] = $methodSynopsis;
        }
    }

    return $result;
}

/**
 * @param array&lt;string, FuncInfo&gt; $funcMap
 * @param array&lt;string, FuncInfo&gt; $aliasMap
 * @param array&lt;int, string&gt; $methodSynopsisWarnings
 * @param array&lt;string, FuncInfo&gt; $undocumentedFuncMap
 * @return array&lt;string, string&gt;
 */
function replaceMethodSynopses(
    string $targetDirectory,
    array $funcMap,
    array $aliasMap,
    bool $isVerifyManual,
    array &amp;$methodSynopsisWarnings,
    array &amp;$undocumentedFuncMap
): array {
    /** @var array&lt;string, string&gt; $documentedFuncMap */
    $documentedFuncMap = [];
    /** @var array&lt;string, string&gt; $methodSynopses */
    $methodSynopses = [];

    $it = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($targetDirectory),
        RecursiveIteratorIterator::LEAVES_ONLY
    );

    foreach ($it as $file) {
        $pathName = $file-&gt;getPathName();
        if (!preg_match(&#039;/\.xml$/i&#039;, $pathName)) {
            continue;
        }

        $xml = file_get_contents($pathName);
        if ($xml === false) {
            continue;
        }

        if ($isVerifyManual) {
            $matches = [];
            preg_match(&quot;/&lt;refname&gt;\s*([\w:]+)\s*&lt;\/refname&gt;\s*&lt;refpurpose&gt;\s*&amp;Alias;\s*&lt;(?:function|methodname)&gt;\s*([\w:]+)\s*&lt;\/(?:function|methodname)&gt;\s*&lt;\/refpurpose&gt;/i&quot;, $xml, $matches);
            $aliasName = $matches[1] ?? null;
            $alias = $funcMap[$aliasName] ?? null;
            $funcName = $matches[2] ?? null;
            $func = $funcMap[$funcName] ?? null;

            if ($alias &amp;&amp;
                !$alias-&gt;isUndocumentable &amp;&amp;
                ($func === null || $func-&gt;alias === null || $func-&gt;alias-&gt;__toString() !== $aliasName) &amp;&amp;
                ($alias-&gt;alias === null || $alias-&gt;alias-&gt;__toString() !== $funcName)
            ) {
                $methodSynopsisWarnings[] = &quot;$aliasName()&quot; . ($alias-&gt;alias ? &quot; is an alias of &quot; . $alias-&gt;alias-&gt;__toString() . &quot;(), but it&quot; : &quot;&quot;) . &quot; is incorrectly documented as an alias for $funcName()&quot;;
            }

            $matches = [];
            preg_match(&quot;/&lt;(?:para|simpara)&gt;\s*(?:&amp;info.function.alias;|&amp;info.method.alias;|&amp;Alias;)\s+&lt;(?:function|methodname)&gt;\s*([\w:]+)\s*&lt;\/(?:function|methodname)&gt;/i&quot;, $xml, $matches);
            $descriptionFuncName = $matches[1] ?? null;
            $descriptionFunc = $funcMap[$descriptionFuncName] ?? null;
            if ($descriptionFunc &amp;&amp; $funcName !== $descriptionFuncName) {
                $methodSynopsisWarnings[] = &quot;Alias in the method synopsis description of $pathName doesn&#039;t match the alias in the &lt;refpurpose&gt;&quot;;
            }

            if ($aliasName) {
                $documentedFuncMap[$aliasName] = $aliasName;
            }
        }

        if (stripos($xml, &quot;&lt;methodsynopsis&quot;) === false &amp;&amp; stripos($xml, &quot;&lt;constructorsynopsis&quot;) === false &amp;&amp; stripos($xml, &quot;&lt;destructorsynopsis&quot;) === false) {
            continue;
        }

        $replacedXml = getReplacedSynopsisXml($xml);

        $doc = new DOMDocument();
        $doc-&gt;formatOutput = false;
        $doc-&gt;preserveWhiteSpace = true;
        $doc-&gt;validateOnParse = true;
        $success = $doc-&gt;loadXML($replacedXml);
        if (!$success) {
            echo &quot;Failed opening $pathName\n&quot;;
            continue;
        }

        $methodSynopsisElements = [];
        foreach ($doc-&gt;getElementsByTagName(&quot;constructorsynopsis&quot;) as $element) {
            $methodSynopsisElements[] = $element;
        }
        foreach ($doc-&gt;getElementsByTagName(&quot;destructorsynopsis&quot;) as $element) {
            $methodSynopsisElements[] = $element;
        }
        foreach ($doc-&gt;getElementsByTagName(&quot;methodsynopsis&quot;) as $element) {
            $methodSynopsisElements[] = $element;
        }

        foreach ($methodSynopsisElements as $methodSynopsis) {
            if (!$methodSynopsis instanceof DOMElement) {
                continue;
            }

            $item = $methodSynopsis-&gt;getElementsByTagName(&quot;methodname&quot;)-&gt;item(0);
            if (!$item instanceof DOMElement) {
                continue;
            }
            $funcName = $item-&gt;textContent;
            if (!isset($funcMap[$funcName])) {
                continue;
            }

            $funcInfo = $funcMap[$funcName];
            $documentedFuncMap[$funcInfo-&gt;name-&gt;__toString()] = $funcInfo-&gt;name-&gt;__toString();

            $newMethodSynopsis = $funcInfo-&gt;getMethodSynopsisElement($funcMap, $aliasMap, $doc);
            if ($newMethodSynopsis === null) {
                continue;
            }

            // Retrieve current signature

            $params = [];
            $list = $methodSynopsis-&gt;getElementsByTagName(&quot;methodparam&quot;);
            foreach ($list as $i =&gt; $item) {
                if (!$item instanceof DOMElement) {
                    continue;
                }

                $paramList = $item-&gt;getElementsByTagName(&quot;parameter&quot;);
                if ($paramList-&gt;count() !== 1) {
                    continue;
                }

                $paramName = $paramList-&gt;item(0)-&gt;textContent;
                $paramTypes = [];

                $paramList = $item-&gt;getElementsByTagName(&quot;type&quot;);
                foreach ($paramList as $type) {
                    if (!$type instanceof DOMElement) {
                        continue;
                    }

                    $paramTypes[] = $type-&gt;textContent;
                }

                $params[$paramName] = [&quot;index&quot; =&gt; $i, &quot;type&quot; =&gt; $paramTypes];
            }

            // Check if there is any change - short circuit if there is not any.

            if (replaceAndCompareXmls($doc, $methodSynopsis, $newMethodSynopsis)) {
                continue;
            }

            // Update parameter references

            $paramList = $doc-&gt;getElementsByTagName(&quot;parameter&quot;);
            /** @var DOMElement $paramElement */
            foreach ($paramList as $paramElement) {
                if ($paramElement-&gt;parentNode &amp;&amp; $paramElement-&gt;parentNode-&gt;nodeName === &quot;methodparam&quot;) {
                    continue;
                }

                $name = $paramElement-&gt;textContent;
                if (!isset($params[$name])) {
                    continue;
                }

                $index = $params[$name][&quot;index&quot;];
                if (!isset($funcInfo-&gt;args[$index])) {
                    continue;
                }

                $paramElement-&gt;textContent = $funcInfo-&gt;args[$index]-&gt;name;
            }

            // Return the updated XML

            $replacedXml = $doc-&gt;saveXML();

            $replacedXml = preg_replace(
                [
                    &quot;/REPLACED-ENTITY-([A-Za-z0-9._{}%-]+?;)/&quot;,
                    &#039;/&lt;refentry\s+xmlns=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                    &#039;/&lt;refentry\s+xmlns=&quot;([^&quot;]+)&quot;\s+xmlns:xlink=&quot;([^&quot;]+)&quot;\s+xml:id=&quot;([^&quot;]+)&quot;\s*&gt;/i&#039;,
                ],
                [
                    &quot;&amp;$1&quot;,
                    &quot;&lt;refentry xml:id=\&quot;$2\&quot; xmlns=\&quot;$1\&quot;&gt;&quot;,
                    &quot;&lt;refentry xml:id=\&quot;$3\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot;&gt;&quot;,
                ],
                $replacedXml
            );

            $methodSynopses[$pathName] = $replacedXml;
        }
    }

    $undocumentedFuncMap = array_diff_key($funcMap, $documentedFuncMap);

    return $methodSynopses;
}

function replaceAndCompareXmls(DOMDocument $doc, DOMElement $originalSynopsis, DOMElement $newSynopsis): bool
{
    $docComparator = new DOMDocument();
    $docComparator-&gt;preserveWhiteSpace = false;
    $docComparator-&gt;formatOutput = true;

    $xml1 = $doc-&gt;saveXML($originalSynopsis);
    $xml1 = getReplacedSynopsisXml($xml1);
    $docComparator-&gt;loadXML($xml1);
    $xml1 = $docComparator-&gt;saveXML();

    $originalSynopsis-&gt;parentNode-&gt;replaceChild($newSynopsis, $originalSynopsis);

    $xml2 = $doc-&gt;saveXML($newSynopsis);
    $xml2 = getReplacedSynopsisXml($xml2);

    $docComparator-&gt;loadXML($xml2);
    $xml2 = $docComparator-&gt;saveXML();

    return $xml1 === $xml2;
}

function installPhpParser(string $version, string $phpParserDir) {
    $lockFile = __DIR__ . &quot;/PHP-Parser-install-lock&quot;;
    $lockFd = fopen($lockFile, &#039;w+&#039;);
    if (!flock($lockFd, LOCK_EX)) {
        throw new Exception(&quot;Failed to acquire installation lock&quot;);
    }

    try {
        // Check whether a parallel process has already installed PHP-Parser.
        if (is_dir($phpParserDir)) {
            return;
        }

        $cwd = getcwd();
        chdir(__DIR__);

        $tarName = &quot;v$version.tar.gz&quot;;
        passthru(&quot;wget https://github.com/nikic/PHP-Parser/archive/$tarName&quot;, $exit);
        if ($exit !== 0) {
            passthru(&quot;curl -LO https://github.com/nikic/PHP-Parser/archive/$tarName&quot;, $exit);
        }
        if ($exit !== 0) {
            throw new Exception(&quot;Failed to download PHP-Parser tarball&quot;);
        }
        if (!mkdir($phpParserDir)) {
            throw new Exception(&quot;Failed to create directory $phpParserDir&quot;);
        }
        passthru(&quot;tar xvzf $tarName -C PHP-Parser-$version --strip-components 1&quot;, $exit);
        if ($exit !== 0) {
            throw new Exception(&quot;Failed to extract PHP-Parser tarball&quot;);
        }
        unlink(__DIR__ . &quot;/$tarName&quot;);
        chdir($cwd);
    } finally {
        flock($lockFd, LOCK_UN);
        @unlink($lockFile);
    }
}

function initPhpParser() {
    static $isInitialized = false;
    if ($isInitialized) {
        return;
    }

    if (!extension_loaded(&quot;tokenizer&quot;)) {
        throw new Exception(&quot;The \&quot;tokenizer\&quot; extension is not available&quot;);
    }

    $isInitialized = true;
    $version = &quot;5.0.0&quot;;
    $phpParserDir = __DIR__ . &quot;/PHP-Parser-$version&quot;;
    if (!is_dir($phpParserDir)) {
        installPhpParser($version, $phpParserDir);
    }

    spl_autoload_register(static function(string $class) use ($phpParserDir) {
        if (strpos($class, &quot;PhpParser\\&quot;) === 0) {
            $fileName = $phpParserDir . &quot;/lib/&quot; . str_replace(&quot;\\&quot;, &quot;/&quot;, $class) . &quot;.php&quot;;
            require $fileName;
        }
    });
}

$optind = null;
$options = getopt(
    &quot;fh&quot;,
    [
        &quot;force-regeneration&quot;, &quot;parameter-stats&quot;, &quot;help&quot;, &quot;verify&quot;, &quot;verify-manual&quot;, &quot;replace-predefined-constants&quot;,
        &quot;generate-classsynopses&quot;, &quot;replace-classsynopses&quot;, &quot;generate-methodsynopses&quot;, &quot;replace-methodsynopses&quot;,
        &quot;generate-optimizer-info&quot;,
    ],
    $optind
);

$context = new Context;
$printParameterStats = isset($options[&quot;parameter-stats&quot;]);
$verify = isset($options[&quot;verify&quot;]);
$verifyManual = isset($options[&quot;verify-manual&quot;]);
$replacePredefinedConstants = isset($options[&quot;replace-predefined-constants&quot;]);
$generateClassSynopses = isset($options[&quot;generate-classsynopses&quot;]);
$replaceClassSynopses = isset($options[&quot;replace-classsynopses&quot;]);
$generateMethodSynopses = isset($options[&quot;generate-methodsynopses&quot;]);
$replaceMethodSynopses = isset($options[&quot;replace-methodsynopses&quot;]);
$generateOptimizerInfo = isset($options[&quot;generate-optimizer-info&quot;]);
$context-&gt;forceRegeneration = isset($options[&quot;f&quot;]) || isset($options[&quot;force-regeneration&quot;]);
$context-&gt;forceParse = $context-&gt;forceRegeneration || $printParameterStats || $verify || $verifyManual || $replacePredefinedConstants || $generateClassSynopses || $generateOptimizerInfo || $replaceClassSynopses || $generateMethodSynopses || $replaceMethodSynopses;

if (isset($options[&quot;h&quot;]) || isset($options[&quot;help&quot;])) {
    die(&quot;\nUsage: gen_stub.php [ -f | --force-regeneration ] [ --replace-predefined-constants ] [ --generate-classsynopses ] [ --replace-classsynopses ] [ --generate-methodsynopses ] [ --replace-methodsynopses ] [ --parameter-stats ] [ --verify ]  [ --verify-manual ] [ --generate-optimizer-info ] [ -h | --help ] [ name.stub.php | directory ] [ directory ]\n\n&quot;);
}

$locations = array_slice($argv, $optind);
$locationCount = count($locations);
if ($replacePredefinedConstants &amp;&amp; $locationCount &lt; 2) {
    die(&quot;At least one source stub path and a target manual directory has to be provided:\n./build/gen_stub.php --replace-predefined-constants ./ ../doc-en/\n&quot;);
}
if ($replaceClassSynopses &amp;&amp; $locationCount &lt; 2) {
    die(&quot;At least one source stub path and a target manual directory has to be provided:\n./build/gen_stub.php --replace-classsynopses ./ ../doc-en/\n&quot;);
}
if ($generateMethodSynopses &amp;&amp; $locationCount &lt; 2) {
    die(&quot;At least one source stub path and a target manual directory has to be provided:\n./build/gen_stub.php --generate-methodsynopses ./ ../doc-en/\n&quot;);
}
if ($replaceMethodSynopses &amp;&amp; $locationCount &lt; 2) {
    die(&quot;At least one source stub path and a target manual directory has to be provided:\n./build/gen_stub.php --replace-methodsynopses ./ ../doc-en/\n&quot;);
}
if ($verifyManual &amp;&amp; $locationCount &lt; 2) {
    die(&quot;At least one source stub path and a target manual directory has to be provided:\n./build/gen_stub.php --verify-manual ./ ../doc-en/\n&quot;);
}
$manualTarget = null;
if ($replacePredefinedConstants || $replaceClassSynopses || $generateMethodSynopses || $replaceMethodSynopses || $verifyManual) {
    $manualTarget = array_pop($locations);
}
if ($locations === []) {
    $locations = [&#039;.&#039;];
}

$fileInfos = [];
foreach (array_unique($locations) as $location) {
    if (is_file($location)) {
        // Generate single file.
        $fileInfo = processStubFile($location, $context);
        if ($fileInfo) {
            $fileInfos[] = $fileInfo;
        }
    } else if (is_dir($location)) {
        array_push($fileInfos, ...processDirectory($location, $context));
    } else {
        echo &quot;$location is neither a file nor a directory.\n&quot;;
        exit(1);
    }
}

if ($printParameterStats) {
    $parameterStats = [];

    foreach ($fileInfos as $fileInfo) {
        foreach ($fileInfo-&gt;getAllFuncInfos() as $funcInfo) {
            foreach ($funcInfo-&gt;args as $argInfo) {
                if (!isset($parameterStats[$argInfo-&gt;name])) {
                    $parameterStats[$argInfo-&gt;name] = 0;
                }
                $parameterStats[$argInfo-&gt;name]++;
            }
        }
    }

    arsort($parameterStats);
    echo json_encode($parameterStats, JSON_PRETTY_PRINT), &quot;\n&quot;;
}

/** @var array&lt;string, ClassInfo&gt; $classMap */
$classMap = [];
/** @var array&lt;string, FuncInfo&gt; $funcMap */
$funcMap = [];
/** @var array&lt;string, FuncInfo&gt; $aliasMap */
$aliasMap = [];

/** @var array&lt;string, ConstInfo&gt; $undocumentedConstMap */
$undocumentedConstMap = [];
/** @var array&lt;string, ClassInfo&gt; $undocumentedClassMap */
$undocumentedClassMap = [];
/** @var array&lt;string, FuncInfo&gt; $undocumentedFuncMap */
$undocumentedFuncMap = [];
/** @var array&lt;int, string&gt; $methodSynopsisWarnings */
$methodSynopsisWarnings = [];

foreach ($fileInfos as $fileInfo) {
    foreach ($fileInfo-&gt;getAllFuncInfos() as $funcInfo) {
        $funcMap[$funcInfo-&gt;name-&gt;__toString()] = $funcInfo;

        // TODO: Don&#039;t use aliasMap for methodsynopsis?
        if ($funcInfo-&gt;aliasType === &quot;alias&quot;) {
            $aliasMap[$funcInfo-&gt;alias-&gt;__toString()] = $funcInfo;
        }
    }

    foreach ($fileInfo-&gt;classInfos as $classInfo) {
        $classMap[$classInfo-&gt;name-&gt;__toString()] = $classInfo;

        if ($classInfo-&gt;alias !== null) {
            $classMap[$classInfo-&gt;alias] = $classInfo;
        }
    }
}

if ($verify) {
    $errors = [];

    foreach ($funcMap as $aliasFunc) {
        if (!$aliasFunc-&gt;alias || $aliasFunc-&gt;aliasType !== &quot;alias&quot;) {
            continue;
        }

        if (!isset($funcMap[$aliasFunc-&gt;alias-&gt;__toString()])) {
            $errors[] = &quot;Aliased function {$aliasFunc-&gt;alias}() cannot be found&quot;;
            continue;
        }

        if (!$aliasFunc-&gt;verify) {
            continue;
        }

        $aliasedFunc = $funcMap[$aliasFunc-&gt;alias-&gt;__toString()];
        $aliasedArgs = $aliasedFunc-&gt;args;
        $aliasArgs = $aliasFunc-&gt;args;

        if ($aliasFunc-&gt;isInstanceMethod() !== $aliasedFunc-&gt;isInstanceMethod()) {
            if ($aliasFunc-&gt;isInstanceMethod()) {
                $aliasedArgs = array_slice($aliasedArgs, 1);
            }

            if ($aliasedFunc-&gt;isInstanceMethod()) {
                $aliasArgs = array_slice($aliasArgs, 1);
            }
        }

        array_map(
            function(?ArgInfo $aliasArg, ?ArgInfo $aliasedArg) use ($aliasFunc, $aliasedFunc, &amp;$errors) {
                if ($aliasArg === null) {
                    assert($aliasedArg !== null);
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() is missing&quot;;
                    return null;
                }

                if ($aliasedArg === null) {
                    $errors[] = &quot;{$aliasedFunc-&gt;name}(): Argument \$$aliasArg-&gt;name of alias function {$aliasFunc-&gt;name}() is missing&quot;;
                    return null;
                }

                if ($aliasArg-&gt;name !== $aliasedArg-&gt;name) {
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasArg-&gt;name and argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() must have the same name&quot;;
                    return null;
                }

                if ($aliasArg-&gt;type != $aliasedArg-&gt;type) {
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasArg-&gt;name and argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() must have the same type&quot;;
                }

                if ($aliasArg-&gt;defaultValue !== $aliasedArg-&gt;defaultValue) {
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasArg-&gt;name and argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() must have the same default value&quot;;
                }
            },
            $aliasArgs, $aliasedArgs
        );

        $aliasedReturn = $aliasedFunc-&gt;return;
        $aliasReturn = $aliasFunc-&gt;return;

        if (!$aliasedFunc-&gt;name-&gt;isConstructor() &amp;&amp; !$aliasFunc-&gt;name-&gt;isConstructor()) {
            $aliasedReturnType = $aliasedReturn-&gt;type ?? $aliasedReturn-&gt;phpDocType;
            $aliasReturnType = $aliasReturn-&gt;type ?? $aliasReturn-&gt;phpDocType;
            if ($aliasReturnType != $aliasedReturnType) {
                $errors[] = &quot;{$aliasFunc-&gt;name}() and {$aliasedFunc-&gt;name}() must have the same return type&quot;;
            }
        }

        $aliasedPhpDocReturnType = $aliasedReturn-&gt;phpDocType;
        $aliasPhpDocReturnType = $aliasReturn-&gt;phpDocType;
        if ($aliasedPhpDocReturnType != $aliasPhpDocReturnType &amp;&amp; $aliasedPhpDocReturnType != $aliasReturn-&gt;type &amp;&amp; $aliasPhpDocReturnType != $aliasedReturn-&gt;type) {
            $errors[] = &quot;{$aliasFunc-&gt;name}() and {$aliasedFunc-&gt;name}() must have the same PHPDoc return type&quot;;
        }
    }

    echo implode(&quot;\n&quot;, $errors);
    if (!empty($errors)) {
        echo &quot;\n&quot;;
        exit(1);
    }
}

if ($replacePredefinedConstants || $verifyManual) {
    $predefinedConstants = replacePredefinedConstants($manualTarget, $context-&gt;allConstInfos, $undocumentedConstMap);

    if ($replacePredefinedConstants) {
        foreach ($predefinedConstants as $filename =&gt; $content) {
            if (file_put_contents($filename, $content)) {
                echo &quot;Saved $filename\n&quot;;
            }
        }
    }
}

if ($generateClassSynopses) {
    $classSynopsesDirectory = getcwd() . &quot;/classsynopses&quot;;

    $classSynopses = generateClassSynopses($classMap, $context-&gt;allConstInfos);
    if (!empty($classSynopses)) {
        if (!file_exists($classSynopsesDirectory)) {
            mkdir($classSynopsesDirectory);
        }

        foreach ($classSynopses as $filename =&gt; $content) {
            if (file_put_contents(&quot;$classSynopsesDirectory/$filename&quot;, $content)) {
                echo &quot;Saved $filename\n&quot;;
            }
        }
    }
}

if ($replaceClassSynopses || $verifyManual) {
    $classSynopses = replaceClassSynopses($manualTarget, $classMap, $context-&gt;allConstInfos, $undocumentedClassMap);

    if ($replaceClassSynopses) {
        foreach ($classSynopses as $filename =&gt; $content) {
            if (file_put_contents($filename, $content)) {
                echo &quot;Saved $filename\n&quot;;
            }
        }
    }
}

if ($generateMethodSynopses) {
    $methodSynopses = generateMethodSynopses($funcMap, $aliasMap);
    if (!file_exists($manualTarget)) {
        mkdir($manualTarget);
    }

    foreach ($methodSynopses as $filename =&gt; $content) {
        if (!file_exists(&quot;$manualTarget/$filename&quot;)) {
            if (file_put_contents(&quot;$manualTarget/$filename&quot;, $content)) {
                echo &quot;Saved $filename\n&quot;;
            }
        }
    }
}

if ($replaceMethodSynopses || $verifyManual) {
    $methodSynopses = replaceMethodSynopses($manualTarget, $funcMap, $aliasMap, $verifyManual, $methodSynopsisWarnings, $undocumentedFuncMap);

    if ($replaceMethodSynopses) {
        foreach ($methodSynopses as $filename =&gt; $content) {
            if (file_put_contents($filename, $content)) {
                echo &quot;Saved $filename\n&quot;;
            }
        }
    }
}

if ($generateOptimizerInfo) {
    $filename = dirname(__FILE__, 2) . &quot;/Zend/Optimizer/zend_func_infos.h&quot;;
    $optimizerInfo = generateOptimizerInfo($funcMap);

    if (file_put_contents($filename, $optimizerInfo)) {
        echo &quot;Saved $filename\n&quot;;
    }
}

if ($verifyManual) {
    foreach ($undocumentedConstMap as $constName =&gt; $info) {
        if ($info-&gt;name-&gt;isClassConst() || $info-&gt;isUndocumentable) {
            continue;
        }

        echo &quot;Warning: Missing predefined constant for $constName\n&quot;;
    }

    foreach ($methodSynopsisWarnings as $warning) {
        echo &quot;Warning: $warning\n&quot;;
    }

    foreach ($undocumentedClassMap as $className =&gt; $info) {
        if (!$info-&gt;isUndocumentable) {
            echo &quot;Warning: Missing class synopsis for $className\n&quot;;
        }
    }

    foreach ($undocumentedFuncMap as $functionName =&gt; $info) {
        if (!$info-&gt;isUndocumentable) {
            echo &quot;Warning: Missing method synopsis for $functionName()\n&quot;;
        }
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FPHP845%2Flib%2Fphp%2Fbuild'>🔙 Back</a></p>