<form method="POST">
    <h3>Editing: PrettyPrinterAbstract.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

namespace PhpParser;

use PhpParser\Internal\DiffElem;
use PhpParser\Internal\Differ;
use PhpParser\Internal\PrintableNewAnonClassNode;
use PhpParser\Internal\TokenStream;
use PhpParser\Node\AttributeGroup;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\AssignOp;
use PhpParser\Node\Expr\BinaryOp;
use PhpParser\Node\Expr\Cast;
use PhpParser\Node\IntersectionType;
use PhpParser\Node\MatchArm;
use PhpParser\Node\Param;
use PhpParser\Node\Scalar;
use PhpParser\Node\Stmt;
use PhpParser\Node\UnionType;

abstract class PrettyPrinterAbstract implements PrettyPrinter {
    protected const FIXUP_PREC_LEFT = 0; // LHS operand affected by precedence
    protected const FIXUP_PREC_RIGHT = 1; // RHS operand affected by precedence
    protected const FIXUP_PREC_UNARY = 2; // Only operand affected by precedence
    protected const FIXUP_CALL_LHS = 3; // LHS of call
    protected const FIXUP_DEREF_LHS = 4; // LHS of dereferencing operation
    protected const FIXUP_STATIC_DEREF_LHS = 5; // LHS of static dereferencing operation
    protected const FIXUP_BRACED_NAME  = 6; // Name operand that may require bracing
    protected const FIXUP_VAR_BRACED_NAME = 7; // Name operand that may require ${} bracing
    protected const FIXUP_ENCAPSED = 8; // Encapsed string part
    protected const FIXUP_NEW = 9; // New/instanceof operand

    protected const MAX_PRECEDENCE = 1000;

    /** @var array&lt;class-string, array{int, int, int}&gt; */
    protected array $precedenceMap = [
        // [precedence, precedenceLHS, precedenceRHS]
        // Where the latter two are the precedences to use for the LHS and RHS of a binary operator,
        // where 1 is added to one of the sides depending on associativity. This information is not
        // used for unary operators and set to -1.
        Expr\Clone_::class             =&gt; [-10,   0,   1],
        BinaryOp\Pow::class            =&gt; [  0,   0,   1],
        Expr\BitwiseNot::class         =&gt; [ 10,  -1,  -1],
        Expr\UnaryPlus::class          =&gt; [ 10,  -1,  -1],
        Expr\UnaryMinus::class         =&gt; [ 10,  -1,  -1],
        Cast\Int_::class               =&gt; [ 10,  -1,  -1],
        Cast\Double::class             =&gt; [ 10,  -1,  -1],
        Cast\String_::class            =&gt; [ 10,  -1,  -1],
        Cast\Array_::class             =&gt; [ 10,  -1,  -1],
        Cast\Object_::class            =&gt; [ 10,  -1,  -1],
        Cast\Bool_::class              =&gt; [ 10,  -1,  -1],
        Cast\Unset_::class             =&gt; [ 10,  -1,  -1],
        Expr\ErrorSuppress::class      =&gt; [ 10,  -1,  -1],
        Expr\Instanceof_::class        =&gt; [ 20,  -1,  -1],
        Expr\BooleanNot::class         =&gt; [ 30,  -1,  -1],
        BinaryOp\Mul::class            =&gt; [ 40,  41,  40],
        BinaryOp\Div::class            =&gt; [ 40,  41,  40],
        BinaryOp\Mod::class            =&gt; [ 40,  41,  40],
        BinaryOp\Plus::class           =&gt; [ 50,  51,  50],
        BinaryOp\Minus::class          =&gt; [ 50,  51,  50],
        BinaryOp\Concat::class         =&gt; [ 50,  51,  50],
        BinaryOp\ShiftLeft::class      =&gt; [ 60,  61,  60],
        BinaryOp\ShiftRight::class     =&gt; [ 60,  61,  60],
        BinaryOp\Smaller::class        =&gt; [ 70,  70,  70],
        BinaryOp\SmallerOrEqual::class =&gt; [ 70,  70,  70],
        BinaryOp\Greater::class        =&gt; [ 70,  70,  70],
        BinaryOp\GreaterOrEqual::class =&gt; [ 70,  70,  70],
        BinaryOp\Equal::class          =&gt; [ 80,  80,  80],
        BinaryOp\NotEqual::class       =&gt; [ 80,  80,  80],
        BinaryOp\Identical::class      =&gt; [ 80,  80,  80],
        BinaryOp\NotIdentical::class   =&gt; [ 80,  80,  80],
        BinaryOp\Spaceship::class      =&gt; [ 80,  80,  80],
        BinaryOp\BitwiseAnd::class     =&gt; [ 90,  91,  90],
        BinaryOp\BitwiseXor::class     =&gt; [100, 101, 100],
        BinaryOp\BitwiseOr::class      =&gt; [110, 111, 110],
        BinaryOp\BooleanAnd::class     =&gt; [120, 121, 120],
        BinaryOp\BooleanOr::class      =&gt; [130, 131, 130],
        BinaryOp\Coalesce::class       =&gt; [140, 140, 141],
        Expr\Ternary::class            =&gt; [150,  -1,  -1],
        Expr\Assign::class             =&gt; [160,  -1,  -1],
        Expr\AssignRef::class          =&gt; [160,  -1,  -1],
        AssignOp\Plus::class           =&gt; [160,  -1,  -1],
        AssignOp\Minus::class          =&gt; [160,  -1,  -1],
        AssignOp\Mul::class            =&gt; [160,  -1,  -1],
        AssignOp\Div::class            =&gt; [160,  -1,  -1],
        AssignOp\Concat::class         =&gt; [160,  -1,  -1],
        AssignOp\Mod::class            =&gt; [160,  -1,  -1],
        AssignOp\BitwiseAnd::class     =&gt; [160,  -1,  -1],
        AssignOp\BitwiseOr::class      =&gt; [160,  -1,  -1],
        AssignOp\BitwiseXor::class     =&gt; [160,  -1,  -1],
        AssignOp\ShiftLeft::class      =&gt; [160,  -1,  -1],
        AssignOp\ShiftRight::class     =&gt; [160,  -1,  -1],
        AssignOp\Pow::class            =&gt; [160,  -1,  -1],
        AssignOp\Coalesce::class       =&gt; [160,  -1,  -1],
        Expr\YieldFrom::class          =&gt; [170,  -1,  -1],
        Expr\Yield_::class             =&gt; [175,  -1,  -1],
        Expr\Print_::class             =&gt; [180,  -1,  -1],
        BinaryOp\LogicalAnd::class     =&gt; [190, 191, 190],
        BinaryOp\LogicalXor::class     =&gt; [200, 201, 200],
        BinaryOp\LogicalOr::class      =&gt; [210, 211, 210],
        Expr\Include_::class           =&gt; [220,  -1,  -1],
        Expr\ArrowFunction::class      =&gt; [230,  -1,  -1],
        Expr\Throw_::class             =&gt; [240,  -1,  -1],
    ];

    /** @var int Current indentation level. */
    protected int $indentLevel;
    /** @var string Newline style. Does not include current indentation. */
    protected string $newline;
    /** @var string Newline including current indentation. */
    protected string $nl;
    /** @var string|null Token placed at end of doc string to ensure it is followed by a newline.
     *                   Null if flexible doc strings are used. */
    protected ?string $docStringEndToken;
    /** @var bool Whether semicolon namespaces can be used (i.e. no global namespace is used) */
    protected bool $canUseSemicolonNamespaces;
    /** @var bool Whether to use short array syntax if the node specifies no preference */
    protected bool $shortArraySyntax;
    /** @var PhpVersion PHP version to target */
    protected PhpVersion $phpVersion;

    /** @var TokenStream|null Original tokens for use in format-preserving pretty print */
    protected ?TokenStream $origTokens;
    /** @var Internal\Differ&lt;Node&gt; Differ for node lists */
    protected Differ $nodeListDiffer;
    /** @var array&lt;string, bool&gt; Map determining whether a certain character is a label character */
    protected array $labelCharMap;
    /**
     * @var array&lt;string, array&lt;string, int&gt;&gt; Map from token classes and subnode names to FIXUP_* constants.
     *                                        This is used during format-preserving prints to place additional parens/braces if necessary.
     */
    protected array $fixupMap;
    /**
     * @var array&lt;string, array{left?: int|string, right?: int|string}&gt; Map from &quot;{$node-&gt;getType()}-&gt;{$subNode}&quot;
     *                                                                  to ['left' =&gt; $l, 'right' =&gt; $r], where $l and $r specify the token type that needs to be stripped
     *                                                                  when removing this node.
     */
    protected array $removalMap;
    /**
     * @var array&lt;string, array{int|string|null, bool, string|null, string|null}&gt; Map from
     *                                                                            &quot;{$node-&gt;getType()}-&gt;{$subNode}&quot; to [$find, $beforeToken, $extraLeft, $extraRight].
     *                                                                            $find is an optional token after which the insertion occurs. $extraLeft/Right
     *                                                                            are optionally added before/after the main insertions.
     */
    protected array $insertionMap;
    /**
     * @var array&lt;string, string&gt; Map From &quot;{$class}-&gt;{$subNode}&quot; to string that should be inserted
     *                            between elements of this list subnode.
     */
    protected array $listInsertionMap;

    /**
     * @var array&lt;string, array{int|string|null, string, string}&gt;
     */
    protected array $emptyListInsertionMap;
    /** @var array&lt;string, array{string, int}&gt; Map from &quot;{$class}-&gt;{$subNode}&quot; to [$printFn, $token]
     *       where $printFn is the function to print the modifiers and $token is the token before which
     *       the modifiers should be reprinted. */
    protected array $modifierChangeMap;

    /**
     * Creates a pretty printer instance using the given options.
     *
     * Supported options:
     *  * PhpVersion $phpVersion: The PHP version to target (default to PHP 7.4). This option
     *                            controls compatibility of the generated code with older PHP
     *                            versions in cases where a simple stylistic choice exists (e.g.
     *                            array() vs []). It is safe to pretty-print an AST for a newer
     *                            PHP version while specifying an older target (but the result will
     *                            of course not be compatible with the older version in that case).
     *  * string $newline:        The newline style to use. Should be &quot;\n&quot; (default) or &quot;\r\n&quot;.
     *  * bool $shortArraySyntax: Whether to use [] instead of array() as the default array
     *                            syntax, if the node does not specify a format. Defaults to whether
     *                            the phpVersion support short array syntax.
     *
     * @param array{
     *     phpVersion?: PhpVersion, newline?: string, shortArraySyntax?: bool
     * } $options Dictionary of formatting options
     */
    public function __construct(array $options = []) {
        $this-&gt;phpVersion = $options['phpVersion'] ?? PhpVersion::fromComponents(7, 4);

        $this-&gt;newline = $options['newline'] ?? &quot;\n&quot;;
        if ($this-&gt;newline !== &quot;\n&quot; &amp;&amp; $this-&gt;newline != &quot;\r\n&quot;) {
            throw new \LogicException('Option &quot;newline&quot; must be one of &quot;\n&quot; or &quot;\r\n&quot;');
        }

        $this-&gt;shortArraySyntax =
            $options['shortArraySyntax'] ?? $this-&gt;phpVersion-&gt;supportsShortArraySyntax();
        $this-&gt;docStringEndToken =
            $this-&gt;phpVersion-&gt;supportsFlexibleHeredoc() ? null : '_DOC_STRING_END_' . mt_rand();
    }

    /**
     * Reset pretty printing state.
     */
    protected function resetState(): void {
        $this-&gt;indentLevel = 0;
        $this-&gt;nl = $this-&gt;newline;
        $this-&gt;origTokens = null;
    }

    /**
     * Set indentation level
     *
     * @param int $level Level in number of spaces
     */
    protected function setIndentLevel(int $level): void {
        $this-&gt;indentLevel = $level;
        $this-&gt;nl = $this-&gt;newline . \str_repeat(' ', $level);
    }

    /**
     * Increase indentation level.
     */
    protected function indent(): void {
        $this-&gt;indentLevel += 4;
        $this-&gt;nl .= '    ';
    }

    /**
     * Decrease indentation level.
     */
    protected function outdent(): void {
        assert($this-&gt;indentLevel &gt;= 4);
        $this-&gt;indentLevel -= 4;
        $this-&gt;nl = $this-&gt;newline . str_repeat(' ', $this-&gt;indentLevel);
    }

    /**
     * Pretty prints an array of statements.
     *
     * @param Node[] $stmts Array of statements
     *
     * @return string Pretty printed statements
     */
    public function prettyPrint(array $stmts): string {
        $this-&gt;resetState();
        $this-&gt;preprocessNodes($stmts);

        return ltrim($this-&gt;handleMagicTokens($this-&gt;pStmts($stmts, false)));
    }

    /**
     * Pretty prints an expression.
     *
     * @param Expr $node Expression node
     *
     * @return string Pretty printed node
     */
    public function prettyPrintExpr(Expr $node): string {
        $this-&gt;resetState();
        return $this-&gt;handleMagicTokens($this-&gt;p($node));
    }

    /**
     * Pretty prints a file of statements (includes the opening &lt;?php tag if it is required).
     *
     * @param Node[] $stmts Array of statements
     *
     * @return string Pretty printed statements
     */
    public function prettyPrintFile(array $stmts): string {
        if (!$stmts) {
            return &quot;&lt;?php&quot; . $this-&gt;newline . $this-&gt;newline;
        }

        $p = &quot;&lt;?php&quot; . $this-&gt;newline . $this-&gt;newline . $this-&gt;prettyPrint($stmts);

        if ($stmts[0] instanceof Stmt\InlineHTML) {
            $p = preg_replace('/^&lt;\?php\s+\?&gt;\r?\n?/', '', $p);
        }
        if ($stmts[count($stmts) - 1] instanceof Stmt\InlineHTML) {
            $p = preg_replace('/&lt;\?php$/', '', rtrim($p));
        }

        return $p;
    }

    /**
     * Preprocesses the top-level nodes to initialize pretty printer state.
     *
     * @param Node[] $nodes Array of nodes
     */
    protected function preprocessNodes(array $nodes): void {
        /* We can use semicolon-namespaces unless there is a global namespace declaration */
        $this-&gt;canUseSemicolonNamespaces = true;
        foreach ($nodes as $node) {
            if ($node instanceof Stmt\Namespace_ &amp;&amp; null === $node-&gt;name) {
                $this-&gt;canUseSemicolonNamespaces = false;
                break;
            }
        }
    }

    /**
     * Handles (and removes) doc-string-end tokens.
     */
    protected function handleMagicTokens(string $str): string {
        if ($this-&gt;docStringEndToken !== null) {
            // Replace doc-string-end tokens with nothing or a newline
            $str = str_replace(
                $this-&gt;docStringEndToken . ';' . $this-&gt;newline,
                ';' . $this-&gt;newline,
                $str);
            $str = str_replace($this-&gt;docStringEndToken, $this-&gt;newline, $str);
        }

        return $str;
    }

    /**
     * Pretty prints an array of nodes (statements) and indents them optionally.
     *
     * @param Node[] $nodes Array of nodes
     * @param bool $indent Whether to indent the printed nodes
     *
     * @return string Pretty printed statements
     */
    protected function pStmts(array $nodes, bool $indent = true): string {
        if ($indent) {
            $this-&gt;indent();
        }

        $result = '';
        foreach ($nodes as $node) {
            $comments = $node-&gt;getComments();
            if ($comments) {
                $result .= $this-&gt;nl . $this-&gt;pComments($comments);
                if ($node instanceof Stmt\Nop) {
                    continue;
                }
            }

            $result .= $this-&gt;nl . $this-&gt;p($node);
        }

        if ($indent) {
            $this-&gt;outdent();
        }

        return $result;
    }

    /**
     * Pretty-print an infix operation while taking precedence into account.
     *
     * @param string $class Node class of operator
     * @param Node $leftNode Left-hand side node
     * @param string $operatorString String representation of the operator
     * @param Node $rightNode Right-hand side node
     * @param int $precedence Precedence of parent operator
     * @param int $lhsPrecedence Precedence for unary operator on LHS of binary operator
     *
     * @return string Pretty printed infix operation
     */
    protected function pInfixOp(
        string $class, Node $leftNode, string $operatorString, Node $rightNode,
        int $precedence, int $lhsPrecedence
    ): string {
        list($opPrecedence, $newPrecedenceLHS, $newPrecedenceRHS) = $this-&gt;precedenceMap[$class];
        $prefix = '';
        $suffix = '';
        if ($opPrecedence &gt;= $precedence) {
            $prefix = '(';
            $suffix = ')';
            $lhsPrecedence = self::MAX_PRECEDENCE;
        }
        return $prefix . $this-&gt;p($leftNode, $newPrecedenceLHS, $newPrecedenceLHS)
            . $operatorString . $this-&gt;p($rightNode, $newPrecedenceRHS, $lhsPrecedence) . $suffix;
    }

    /**
     * Pretty-print a prefix operation while taking precedence into account.
     *
     * @param string $class Node class of operator
     * @param string $operatorString String representation of the operator
     * @param Node $node Node
     * @param int $precedence Precedence of parent operator
     * @param int $lhsPrecedence Precedence for unary operator on LHS of binary operator
     *
     * @return string Pretty printed prefix operation
     */
    protected function pPrefixOp(string $class, string $operatorString, Node $node, int $precedence, int $lhsPrecedence): string {
        $opPrecedence = $this-&gt;precedenceMap[$class][0];
        $prefix = '';
        $suffix = '';
        if ($opPrecedence &gt;= $lhsPrecedence) {
            $prefix = '(';
            $suffix = ')';
            $lhsPrecedence = self::MAX_PRECEDENCE;
        }
        $printedArg = $this-&gt;p($node, $opPrecedence, $lhsPrecedence);
        if (($operatorString === '+' &amp;&amp; $printedArg[0] === '+') ||
            ($operatorString === '-' &amp;&amp; $printedArg[0] === '-')
        ) {
            // Avoid printing +(+$a) as ++$a and similar.
            $printedArg = '(' . $printedArg . ')';
        }
        return $prefix . $operatorString . $printedArg . $suffix;
    }

    /**
     * Pretty-print a postfix operation while taking precedence into account.
     *
     * @param string $class Node class of operator
     * @param string $operatorString String representation of the operator
     * @param Node $node Node
     * @param int $precedence Precedence of parent operator
     * @param int $lhsPrecedence Precedence for unary operator on LHS of binary operator
     *
     * @return string Pretty printed postfix operation
     */
    protected function pPostfixOp(string $class, Node $node, string $operatorString, int $precedence, int $lhsPrecedence): string {
        $opPrecedence = $this-&gt;precedenceMap[$class][0];
        $prefix = '';
        $suffix = '';
        if ($opPrecedence &gt;= $precedence) {
            $prefix = '(';
            $suffix = ')';
            $lhsPrecedence = self::MAX_PRECEDENCE;
        }
        if ($opPrecedence &lt; $lhsPrecedence) {
            $lhsPrecedence = $opPrecedence;
        }
        return $prefix . $this-&gt;p($node, $opPrecedence, $lhsPrecedence) . $operatorString . $suffix;
    }

    /**
     * Pretty prints an array of nodes and implodes the printed values.
     *
     * @param Node[] $nodes Array of Nodes to be printed
     * @param string $glue Character to implode with
     *
     * @return string Imploded pretty printed nodes&gt; $pre
     */
    protected function pImplode(array $nodes, string $glue = ''): string {
        $pNodes = [];
        foreach ($nodes as $node) {
            if (null === $node) {
                $pNodes[] = '';
            } else {
                $pNodes[] = $this-&gt;p($node);
            }
        }

        return implode($glue, $pNodes);
    }

    /**
     * Pretty prints an array of nodes and implodes the printed values with commas.
     *
     * @param Node[] $nodes Array of Nodes to be printed
     *
     * @return string Comma separated pretty printed nodes
     */
    protected function pCommaSeparated(array $nodes): string {
        return $this-&gt;pImplode($nodes, ', ');
    }

    /**
     * Pretty prints a comma-separated list of nodes in multiline style, including comments.
     *
     * The result includes a leading newline and one level of indentation (same as pStmts).
     *
     * @param Node[] $nodes Array of Nodes to be printed
     * @param bool $trailingComma Whether to use a trailing comma
     *
     * @return string Comma separated pretty printed nodes in multiline style
     */
    protected function pCommaSeparatedMultiline(array $nodes, bool $trailingComma): string {
        $this-&gt;indent();

        $result = '';
        $lastIdx = count($nodes) - 1;
        foreach ($nodes as $idx =&gt; $node) {
            if ($node !== null) {
                $comments = $node-&gt;getComments();
                if ($comments) {
                    $result .= $this-&gt;nl . $this-&gt;pComments($comments);
                }

                $result .= $this-&gt;nl . $this-&gt;p($node);
            } else {
                $result .= $this-&gt;nl;
            }
            if ($trailingComma || $idx !== $lastIdx) {
                $result .= ',';
            }
        }

        $this-&gt;outdent();
        return $result;
    }

    /**
     * Prints reformatted text of the passed comments.
     *
     * @param Comment[] $comments List of comments
     *
     * @return string Reformatted text of comments
     */
    protected function pComments(array $comments): string {
        $formattedComments = [];

        foreach ($comments as $comment) {
            $formattedComments[] = str_replace(&quot;\n&quot;, $this-&gt;nl, $comment-&gt;getReformattedText());
        }

        return implode($this-&gt;nl, $formattedComments);
    }

    /**
     * Perform a format-preserving pretty print of an AST.
     *
     * The format preservation is best effort. For some changes to the AST the formatting will not
     * be preserved (at least not locally).
     *
     * In order to use this method a number of prerequisites must be satisfied:
     *  * The startTokenPos and endTokenPos attributes in the lexer must be enabled.
     *  * The CloningVisitor must be run on the AST prior to modification.
     *  * The original tokens must be provided, using the getTokens() method on the lexer.
     *
     * @param Node[] $stmts Modified AST with links to original AST
     * @param Node[] $origStmts Original AST with token offset information
     * @param Token[] $origTokens Tokens of the original code
     */
    public function printFormatPreserving(array $stmts, array $origStmts, array $origTokens): string {
        $this-&gt;initializeNodeListDiffer();
        $this-&gt;initializeLabelCharMap();
        $this-&gt;initializeFixupMap();
        $this-&gt;initializeRemovalMap();
        $this-&gt;initializeInsertionMap();
        $this-&gt;initializeListInsertionMap();
        $this-&gt;initializeEmptyListInsertionMap();
        $this-&gt;initializeModifierChangeMap();

        $this-&gt;resetState();
        $this-&gt;origTokens = new TokenStream($origTokens);

        $this-&gt;preprocessNodes($stmts);

        $pos = 0;
        $result = $this-&gt;pArray($stmts, $origStmts, $pos, 0, 'File', 'stmts', null);
        if (null !== $result) {
            $result .= $this-&gt;origTokens-&gt;getTokenCode($pos, count($origTokens) - 1, 0);
        } else {
            // Fallback
            // TODO Add &lt;?php properly
            $result = &quot;&lt;?php&quot; . $this-&gt;newline . $this-&gt;pStmts($stmts, false);
        }

        return $this-&gt;handleMagicTokens($result);
    }

    protected function pFallback(Node $node, int $precedence, int $lhsPrecedence): string {
        return $this-&gt;{'p' . $node-&gt;getType()}($node, $precedence, $lhsPrecedence);
    }

    /**
     * Pretty prints a node.
     *
     * This method also handles formatting preservation for nodes.
     *
     * @param Node $node Node to be pretty printed
     * @param int $precedence Precedence of parent operator
     * @param int $lhsPrecedence Precedence for unary operator on LHS of binary operator
     * @param bool $parentFormatPreserved Whether parent node has preserved formatting
     *
     * @return string Pretty printed node
     */
    protected function p(
        Node $node, int $precedence = self::MAX_PRECEDENCE, int $lhsPrecedence = self::MAX_PRECEDENCE,
        bool $parentFormatPreserved = false
    ): string {
        // No orig tokens means this is a normal pretty print without preservation of formatting
        if (!$this-&gt;origTokens) {
            return $this-&gt;{'p' . $node-&gt;getType()}($node, $precedence, $lhsPrecedence);
        }

        /** @var Node|null $origNode */
        $origNode = $node-&gt;getAttribute('origNode');
        if (null === $origNode) {
            return $this-&gt;pFallback($node, $precedence, $lhsPrecedence);
        }

        $class = \get_class($node);
        \assert($class === \get_class($origNode));

        $startPos = $origNode-&gt;getStartTokenPos();
        $endPos = $origNode-&gt;getEndTokenPos();
        \assert($startPos &gt;= 0 &amp;&amp; $endPos &gt;= 0);

        $fallbackNode = $node;
        if ($node instanceof Expr\New_ &amp;&amp; $node-&gt;class instanceof Stmt\Class_) {
            // Normalize node structure of anonymous classes
            assert($origNode instanceof Expr\New_);
            $node = PrintableNewAnonClassNode::fromNewNode($node);
            $origNode = PrintableNewAnonClassNode::fromNewNode($origNode);
            $class = PrintableNewAnonClassNode::class;
        }

        // InlineHTML node does not contain closing and opening PHP tags. If the parent formatting
        // is not preserved, then we need to use the fallback code to make sure the tags are
        // printed.
        if ($node instanceof Stmt\InlineHTML &amp;&amp; !$parentFormatPreserved) {
            return $this-&gt;pFallback($fallbackNode, $precedence, $lhsPrecedence);
        }

        $indentAdjustment = $this-&gt;indentLevel - $this-&gt;origTokens-&gt;getIndentationBefore($startPos);

        $type = $node-&gt;getType();
        $fixupInfo = $this-&gt;fixupMap[$class] ?? null;

        $result = '';
        $pos = $startPos;
        foreach ($node-&gt;getSubNodeNames() as $subNodeName) {
            $subNode = $node-&gt;$subNodeName;
            $origSubNode = $origNode-&gt;$subNodeName;

            if ((!$subNode instanceof Node &amp;&amp; $subNode !== null)
                || (!$origSubNode instanceof Node &amp;&amp; $origSubNode !== null)
            ) {
                if ($subNode === $origSubNode) {
                    // Unchanged, can reuse old code
                    continue;
                }

                if (is_array($subNode) &amp;&amp; is_array($origSubNode)) {
                    // Array subnode changed, we might be able to reconstruct it
                    $listResult = $this-&gt;pArray(
                        $subNode, $origSubNode, $pos, $indentAdjustment, $class, $subNodeName,
                        $fixupInfo[$subNodeName] ?? null
                    );
                    if (null === $listResult) {
                        return $this-&gt;pFallback($fallbackNode, $precedence, $lhsPrecedence);
                    }

                    $result .= $listResult;
                    continue;
                }

                // Check if this is a modifier change
                $key = $class . '-&gt;' . $subNodeName;
                if (!isset($this-&gt;modifierChangeMap[$key])) {
                    return $this-&gt;pFallback($fallbackNode, $precedence, $lhsPrecedence);
                }

                [$printFn, $findToken] = $this-&gt;modifierChangeMap[$key];
                $result .= $this-&gt;$printFn($subNode);
                $pos = $this-&gt;origTokens-&gt;findRight($pos, $findToken);
                continue;
            }

            $extraLeft = '';
            $extraRight = '';
            if ($origSubNode !== null) {
                $subStartPos = $origSubNode-&gt;getStartTokenPos();
                $subEndPos = $origSubNode-&gt;getEndTokenPos();
                \assert($subStartPos &gt;= 0 &amp;&amp; $subEndPos &gt;= 0);
            } else {
                if ($subNode === null) {
                    // Both null, nothing to do
                    continue;
                }

                // A node has been inserted, check if we have insertion information for it
                $key = $type . '-&gt;' . $subNodeName;
                if (!isset($this-&gt;insertionMap[$key])) {
                    return $this-&gt;pFallback($fallbackNode, $precedence, $lhsPrecedence);
                }

                list($findToken, $beforeToken, $extraLeft, $extraRight) = $this-&gt;insertionMap[$key];
                if (null !== $findToken) {
                    $subStartPos = $this-&gt;origTokens-&gt;findRight($pos, $findToken)
                        + (int) !$beforeToken;
                } else {
                    $subStartPos = $pos;
                }

                if (null === $extraLeft &amp;&amp; null !== $extraRight) {
                    // If inserting on the right only, skipping whitespace looks better
                    $subStartPos = $this-&gt;origTokens-&gt;skipRightWhitespace($subStartPos);
                }
                $subEndPos = $subStartPos - 1;
            }

            if (null === $subNode) {
                // A node has been removed, check if we have removal information for it
                $key = $type . '-&gt;' . $subNodeName;
                if (!isset($this-&gt;removalMap[$key])) {
                    return $this-&gt;pFallback($fallbackNode, $precedence, $lhsPrecedence);
                }

                // Adjust positions to account for additional tokens that must be skipped
                $removalInfo = $this-&gt;removalMap[$key];
                if (isset($removalInfo['left'])) {
                    $subStartPos = $this-&gt;origTokens-&gt;skipLeft($subStartPos - 1, $removalInfo['left']) + 1;
                }
                if (isset($removalInfo['right'])) {
                    $subEndPos = $this-&gt;origTokens-&gt;skipRight($subEndPos + 1, $removalInfo['right']) - 1;
                }
            }

            $result .= $this-&gt;origTokens-&gt;getTokenCode($pos, $subStartPos, $indentAdjustment);

            if (null !== $subNode) {
                $result .= $extraLeft;

                $origIndentLevel = $this-&gt;indentLevel;
                $this-&gt;setIndentLevel($this-&gt;origTokens-&gt;getIndentationBefore($subStartPos) + $indentAdjustment);

                // If it's the same node that was previously in this position, it certainly doesn't
                // need fixup. It's important to check this here, because our fixup checks are more
                // conservative than strictly necessary.
                if (isset($fixupInfo[$subNodeName])
                    &amp;&amp; $subNode-&gt;getAttribute('origNode') !== $origSubNode
                ) {
                    $fixup = $fixupInfo[$subNodeName];
                    $res = $this-&gt;pFixup($fixup, $subNode, $class, $subStartPos, $subEndPos);
                } else {
                    $res = $this-&gt;p($subNode, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true);
                }

                $this-&gt;safeAppend($result, $res);
                $this-&gt;setIndentLevel($origIndentLevel);

                $result .= $extraRight;
            }

            $pos = $subEndPos + 1;
        }

        $result .= $this-&gt;origTokens-&gt;getTokenCode($pos, $endPos + 1, $indentAdjustment);
        return $result;
    }

    /**
     * Perform a format-preserving pretty print of an array.
     *
     * @param Node[] $nodes New nodes
     * @param Node[] $origNodes Original nodes
     * @param int $pos Current token position (updated by reference)
     * @param int $indentAdjustment Adjustment for indentation
     * @param string $parentNodeClass Class of the containing node.
     * @param string $subNodeName Name of array subnode.
     * @param null|int $fixup Fixup information for array item nodes
     *
     * @return null|string Result of pretty print or null if cannot preserve formatting
     */
    protected function pArray(
        array  $nodes, array $origNodes, int &amp;$pos, int $indentAdjustment,
        string $parentNodeClass, string $subNodeName, ?int $fixup
    ): ?string {
        $diff = $this-&gt;nodeListDiffer-&gt;diffWithReplacements($origNodes, $nodes);

        $mapKey = $parentNodeClass . '-&gt;' . $subNodeName;
        $insertStr = $this-&gt;listInsertionMap[$mapKey] ?? null;
        $isStmtList = $subNodeName === 'stmts';

        $beforeFirstKeepOrReplace = true;
        $skipRemovedNode = false;
        $delayedAdd = [];
        $lastElemIndentLevel = $this-&gt;indentLevel;

        $insertNewline = false;
        if ($insertStr === &quot;\n&quot;) {
            $insertStr = '';
            $insertNewline = true;
        }

        if ($isStmtList &amp;&amp; \count($origNodes) === 1 &amp;&amp; \count($nodes) !== 1) {
            $startPos = $origNodes[0]-&gt;getStartTokenPos();
            $endPos = $origNodes[0]-&gt;getEndTokenPos();
            \assert($startPos &gt;= 0 &amp;&amp; $endPos &gt;= 0);
            if (!$this-&gt;origTokens-&gt;haveBraces($startPos, $endPos)) {
                // This was a single statement without braces, but either additional statements
                // have been added, or the single statement has been removed. This requires the
                // addition of braces. For now fall back.
                // TODO: Try to preserve formatting
                return null;
            }
        }

        $result = '';
        foreach ($diff as $i =&gt; $diffElem) {
            $diffType = $diffElem-&gt;type;
            /** @var Node|string|null $arrItem */
            $arrItem = $diffElem-&gt;new;
            /** @var Node|string|null $origArrItem */
            $origArrItem = $diffElem-&gt;old;

            if ($diffType === DiffElem::TYPE_KEEP || $diffType === DiffElem::TYPE_REPLACE) {
                $beforeFirstKeepOrReplace = false;

                if ($origArrItem === null || $arrItem === null) {
                    // We can only handle the case where both are null
                    if ($origArrItem === $arrItem) {
                        continue;
                    }
                    return null;
                }

                if (!$arrItem instanceof Node || !$origArrItem instanceof Node) {
                    // We can only deal with nodes. This can occur for Names, which use string arrays.
                    return null;
                }

                $itemStartPos = $origArrItem-&gt;getStartTokenPos();
                $itemEndPos = $origArrItem-&gt;getEndTokenPos();
                \assert($itemStartPos &gt;= 0 &amp;&amp; $itemEndPos &gt;= 0 &amp;&amp; $itemStartPos &gt;= $pos);

                $origIndentLevel = $this-&gt;indentLevel;
                $lastElemIndentLevel = $this-&gt;origTokens-&gt;getIndentationBefore($itemStartPos) + $indentAdjustment;
                $this-&gt;setIndentLevel($lastElemIndentLevel);

                $comments = $arrItem-&gt;getComments();
                $origComments = $origArrItem-&gt;getComments();
                $commentStartPos = $origComments ? $origComments[0]-&gt;getStartTokenPos() : $itemStartPos;
                \assert($commentStartPos &gt;= 0);

                if ($commentStartPos &lt; $pos) {
                    // Comments may be assigned to multiple nodes if they start at the same position.
                    // Make sure we don't try to print them multiple times.
                    $commentStartPos = $itemStartPos;
                }

                if ($skipRemovedNode) {
                    if ($isStmtList &amp;&amp; $this-&gt;origTokens-&gt;haveTagInRange($pos, $itemStartPos)) {
                        // We'd remove an opening/closing PHP tag.
                        // TODO: Preserve formatting.
                        $this-&gt;setIndentLevel($origIndentLevel);
                        return null;
                    }
                } else {
                    $result .= $this-&gt;origTokens-&gt;getTokenCode(
                        $pos, $commentStartPos, $indentAdjustment);
                }

                if (!empty($delayedAdd)) {
                    /** @var Node $delayedAddNode */
                    foreach ($delayedAdd as $delayedAddNode) {
                        if ($insertNewline) {
                            $delayedAddComments = $delayedAddNode-&gt;getComments();
                            if ($delayedAddComments) {
                                $result .= $this-&gt;pComments($delayedAddComments) . $this-&gt;nl;
                            }
                        }

                        $this-&gt;safeAppend($result, $this-&gt;p($delayedAddNode, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true));

                        if ($insertNewline) {
                            $result .= $insertStr . $this-&gt;nl;
                        } else {
                            $result .= $insertStr;
                        }
                    }

                    $delayedAdd = [];
                }

                if ($comments !== $origComments) {
                    if ($comments) {
                        $result .= $this-&gt;pComments($comments) . $this-&gt;nl;
                    }
                } else {
                    $result .= $this-&gt;origTokens-&gt;getTokenCode(
                        $commentStartPos, $itemStartPos, $indentAdjustment);
                }

                // If we had to remove anything, we have done so now.
                $skipRemovedNode = false;
            } elseif ($diffType === DiffElem::TYPE_ADD) {
                if (null === $insertStr) {
                    // We don't have insertion information for this list type
                    return null;
                }

                if (!$arrItem instanceof Node) {
                    // We only support list insertion of nodes.
                    return null;
                }

                // We go multiline if the original code was multiline,
                // or if it's an array item with a comment above it.
                // Match always uses multiline formatting.
                if ($insertStr === ', ' &amp;&amp;
                    ($this-&gt;isMultiline($origNodes) || $arrItem-&gt;getComments() ||
                     $parentNodeClass === Expr\Match_::class)
                ) {
                    $insertStr = ',';
                    $insertNewline = true;
                }

                if ($beforeFirstKeepOrReplace) {
                    // Will be inserted at the next &quot;replace&quot; or &quot;keep&quot; element
                    $delayedAdd[] = $arrItem;
                    continue;
                }

                $itemStartPos = $pos;
                $itemEndPos = $pos - 1;

                $origIndentLevel = $this-&gt;indentLevel;
                $this-&gt;setIndentLevel($lastElemIndentLevel);

                if ($insertNewline) {
                    $result .= $insertStr . $this-&gt;nl;
                    $comments = $arrItem-&gt;getComments();
                    if ($comments) {
                        $result .= $this-&gt;pComments($comments) . $this-&gt;nl;
                    }
                } else {
                    $result .= $insertStr;
                }
            } elseif ($diffType === DiffElem::TYPE_REMOVE) {
                if (!$origArrItem instanceof Node) {
                    // We only support removal for nodes
                    return null;
                }

                $itemStartPos = $origArrItem-&gt;getStartTokenPos();
                $itemEndPos = $origArrItem-&gt;getEndTokenPos();
                \assert($itemStartPos &gt;= 0 &amp;&amp; $itemEndPos &gt;= 0);

                // Consider comments part of the node.
                $origComments = $origArrItem-&gt;getComments();
                if ($origComments) {
                    $itemStartPos = $origComments[0]-&gt;getStartTokenPos();
                }

                if ($i === 0) {
                    // If we're removing from the start, keep the tokens before the node and drop those after it,
                    // instead of the other way around.
                    $result .= $this-&gt;origTokens-&gt;getTokenCode(
                        $pos, $itemStartPos, $indentAdjustment);
                    $skipRemovedNode = true;
                } else {
                    if ($isStmtList &amp;&amp; $this-&gt;origTokens-&gt;haveTagInRange($pos, $itemStartPos)) {
                        // We'd remove an opening/closing PHP tag.
                        // TODO: Preserve formatting.
                        return null;
                    }
                }

                $pos = $itemEndPos + 1;
                continue;
            } else {
                throw new \Exception(&quot;Shouldn't happen&quot;);
            }

            if (null !== $fixup &amp;&amp; $arrItem-&gt;getAttribute('origNode') !== $origArrItem) {
                $res = $this-&gt;pFixup($fixup, $arrItem, null, $itemStartPos, $itemEndPos);
            } else {
                $res = $this-&gt;p($arrItem, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true);
            }
            $this-&gt;safeAppend($result, $res);

            $this-&gt;setIndentLevel($origIndentLevel);
            $pos = $itemEndPos + 1;
        }

        if ($skipRemovedNode) {
            // TODO: Support removing single node.
            return null;
        }

        if (!empty($delayedAdd)) {
            if (!isset($this-&gt;emptyListInsertionMap[$mapKey])) {
                return null;
            }

            list($findToken, $extraLeft, $extraRight) = $this-&gt;emptyListInsertionMap[$mapKey];
            if (null !== $findToken) {
                $insertPos = $this-&gt;origTokens-&gt;findRight($pos, $findToken) + 1;
                $result .= $this-&gt;origTokens-&gt;getTokenCode($pos, $insertPos, $indentAdjustment);
                $pos = $insertPos;
            }

            $first = true;
            $result .= $extraLeft;
            foreach ($delayedAdd as $delayedAddNode) {
                if (!$first) {
                    $result .= $insertStr;
                    if ($insertNewline) {
                        $result .= $this-&gt;nl;
                    }
                }
                $result .= $this-&gt;p($delayedAddNode, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true);
                $first = false;
            }
            $result .= $extraRight === &quot;\n&quot; ? $this-&gt;nl : $extraRight;
        }

        return $result;
    }

    /**
     * Print node with fixups.
     *
     * Fixups here refer to the addition of extra parentheses, braces or other characters, that
     * are required to preserve program semantics in a certain context (e.g. to maintain precedence
     * or because only certain expressions are allowed in certain places).
     *
     * @param int $fixup Fixup type
     * @param Node $subNode Subnode to print
     * @param string|null $parentClass Class of parent node
     * @param int $subStartPos Original start pos of subnode
     * @param int $subEndPos Original end pos of subnode
     *
     * @return string Result of fixed-up print of subnode
     */
    protected function pFixup(int $fixup, Node $subNode, ?string $parentClass, int $subStartPos, int $subEndPos): string {
        switch ($fixup) {
            case self::FIXUP_PREC_LEFT:
                // We use a conservative approximation where lhsPrecedence == precedence.
                if (!$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)) {
                    $precedence = $this-&gt;precedenceMap[$parentClass][1];
                    return $this-&gt;p($subNode, $precedence, $precedence);
                }
                break;
            case self::FIXUP_PREC_RIGHT:
                if (!$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)) {
                    $precedence = $this-&gt;precedenceMap[$parentClass][2];
                    return $this-&gt;p($subNode, $precedence, $precedence);
                }
                break;
            case self::FIXUP_PREC_UNARY:
                if (!$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)) {
                    $precedence = $this-&gt;precedenceMap[$parentClass][0];
                    return $this-&gt;p($subNode, $precedence, $precedence);
                }
                break;
            case self::FIXUP_CALL_LHS:
                if ($this-&gt;callLhsRequiresParens($subNode)
                    &amp;&amp; !$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)
                ) {
                    return '(' . $this-&gt;p($subNode) . ')';
                }
                break;
            case self::FIXUP_DEREF_LHS:
                if ($this-&gt;dereferenceLhsRequiresParens($subNode)
                    &amp;&amp; !$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)
                ) {
                    return '(' . $this-&gt;p($subNode) . ')';
                }
                break;
            case self::FIXUP_STATIC_DEREF_LHS:
                if ($this-&gt;staticDereferenceLhsRequiresParens($subNode)
                    &amp;&amp; !$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)
                ) {
                    return '(' . $this-&gt;p($subNode) . ')';
                }
                break;
            case self::FIXUP_NEW:
                if ($this-&gt;newOperandRequiresParens($subNode)
                    &amp;&amp; !$this-&gt;origTokens-&gt;haveParens($subStartPos, $subEndPos)) {
                    return '(' . $this-&gt;p($subNode) . ')';
                }
                break;
            case self::FIXUP_BRACED_NAME:
            case self::FIXUP_VAR_BRACED_NAME:
                if ($subNode instanceof Expr
                    &amp;&amp; !$this-&gt;origTokens-&gt;haveBraces($subStartPos, $subEndPos)
                ) {
                    return ($fixup === self::FIXUP_VAR_BRACED_NAME ? '$' : '')
                        . '{' . $this-&gt;p($subNode) . '}';
                }
                break;
            case self::FIXUP_ENCAPSED:
                if (!$subNode instanceof Node\InterpolatedStringPart
                    &amp;&amp; !$this-&gt;origTokens-&gt;haveBraces($subStartPos, $subEndPos)
                ) {
                    return '{' . $this-&gt;p($subNode) . '}';
                }
                break;
            default:
                throw new \Exception('Cannot happen');
        }

        // Nothing special to do
        return $this-&gt;p($subNode);
    }

    /**
     * Appends to a string, ensuring whitespace between label characters.
     *
     * Example: &quot;echo&quot; and &quot;$x&quot; result in &quot;echo$x&quot;, but &quot;echo&quot; and &quot;x&quot; result in &quot;echo x&quot;.
     * Without safeAppend the result would be &quot;echox&quot;, which does not preserve semantics.
     */
    protected function safeAppend(string &amp;$str, string $append): void {
        if ($str === &quot;&quot;) {
            $str = $append;
            return;
        }

        if ($append === &quot;&quot;) {
            return;
        }

        if (!$this-&gt;labelCharMap[$append[0]]
                || !$this-&gt;labelCharMap[$str[\strlen($str) - 1]]) {
            $str .= $append;
        } else {
            $str .= &quot; &quot; . $append;
        }
    }

    /**
     * Determines whether the LHS of a call must be wrapped in parenthesis.
     *
     * @param Node $node LHS of a call
     *
     * @return bool Whether parentheses are required
     */
    protected function callLhsRequiresParens(Node $node): bool {
        return !($node instanceof Node\Name
            || $node instanceof Expr\Variable
            || $node instanceof Expr\ArrayDimFetch
            || $node instanceof Expr\FuncCall
            || $node instanceof Expr\MethodCall
            || $node instanceof Expr\NullsafeMethodCall
            || $node instanceof Expr\StaticCall
            || $node instanceof Expr\Array_);
    }

    /**
     * Determines whether the LHS of an array/object operation must be wrapped in parentheses.
     *
     * @param Node $node LHS of dereferencing operation
     *
     * @return bool Whether parentheses are required
     */
    protected function dereferenceLhsRequiresParens(Node $node): bool {
        // A constant can occur on the LHS of an array/object deref, but not a static deref.
        return $this-&gt;staticDereferenceLhsRequiresParens($node)
            &amp;&amp; !$node instanceof Expr\ConstFetch;
    }

    /**
     * Determines whether the LHS of a static operation must be wrapped in parentheses.
     *
     * @param Node $node LHS of dereferencing operation
     *
     * @return bool Whether parentheses are required
     */
    protected function staticDereferenceLhsRequiresParens(Node $node): bool {
        return !($node instanceof Expr\Variable
            || $node instanceof Node\Name
            || $node instanceof Expr\ArrayDimFetch
            || $node instanceof Expr\PropertyFetch
            || $node instanceof Expr\NullsafePropertyFetch
            || $node instanceof Expr\StaticPropertyFetch
            || $node instanceof Expr\FuncCall
            || $node instanceof Expr\MethodCall
            || $node instanceof Expr\NullsafeMethodCall
            || $node instanceof Expr\StaticCall
            || $node instanceof Expr\Array_
            || $node instanceof Scalar\String_
            || $node instanceof Expr\ClassConstFetch);
    }

    /**
     * Determines whether an expression used in &quot;new&quot; or &quot;instanceof&quot; requires parentheses.
     *
     * @param Node $node New or instanceof operand
     *
     * @return bool Whether parentheses are required
     */
    protected function newOperandRequiresParens(Node $node): bool {
        if ($node instanceof Node\Name || $node instanceof Expr\Variable) {
            return false;
        }
        if ($node instanceof Expr\ArrayDimFetch || $node instanceof Expr\PropertyFetch ||
            $node instanceof Expr\NullsafePropertyFetch
        ) {
            return $this-&gt;newOperandRequiresParens($node-&gt;var);
        }
        if ($node instanceof Expr\StaticPropertyFetch) {
            return $this-&gt;newOperandRequiresParens($node-&gt;class);
        }
        return true;
    }

    /**
     * Print modifiers, including trailing whitespace.
     *
     * @param int $modifiers Modifier mask to print
     *
     * @return string Printed modifiers
     */
    protected function pModifiers(int $modifiers): string {
        return ($modifiers &amp; Modifiers::FINAL ? 'final ' : '')
             . ($modifiers &amp; Modifiers::ABSTRACT ? 'abstract ' : '')
             . ($modifiers &amp; Modifiers::PUBLIC ? 'public ' : '')
             . ($modifiers &amp; Modifiers::PROTECTED ? 'protected ' : '')
             . ($modifiers &amp; Modifiers::PRIVATE ? 'private ' : '')
             . ($modifiers &amp; Modifiers::STATIC ? 'static ' : '')
             . ($modifiers &amp; Modifiers::READONLY ? 'readonly ' : '');
    }

    protected function pStatic(bool $static): string {
        return $static ? 'static ' : '';
    }

    /**
     * Determine whether a list of nodes uses multiline formatting.
     *
     * @param (Node|null)[] $nodes Node list
     *
     * @return bool Whether multiline formatting is used
     */
    protected function isMultiline(array $nodes): bool {
        if (\count($nodes) &lt; 2) {
            return false;
        }

        $pos = -1;
        foreach ($nodes as $node) {
            if (null === $node) {
                continue;
            }

            $endPos = $node-&gt;getEndTokenPos() + 1;
            if ($pos &gt;= 0) {
                $text = $this-&gt;origTokens-&gt;getTokenCode($pos, $endPos, 0);
                if (false === strpos($text, &quot;\n&quot;)) {
                    // We require that a newline is present between *every* item. If the formatting
                    // is inconsistent, with only some items having newlines, we don't consider it
                    // as multiline
                    return false;
                }
            }
            $pos = $endPos;
        }

        return true;
    }

    /**
     * Lazily initializes label char map.
     *
     * The label char map determines whether a certain character may occur in a label.
     */
    protected function initializeLabelCharMap(): void {
        if (isset($this-&gt;labelCharMap)) {
            return;
        }

        $this-&gt;labelCharMap = [];
        for ($i = 0; $i &lt; 256; $i++) {
            $chr = chr($i);
            $this-&gt;labelCharMap[$chr] = $i &gt;= 0x80 || ctype_alnum($chr);
        }

        if ($this-&gt;phpVersion-&gt;allowsDelInIdentifiers()) {
            $this-&gt;labelCharMap[&quot;\x7f&quot;] = true;
        }
    }

    /**
     * Lazily initializes node list differ.
     *
     * The node list differ is used to determine differences between two array subnodes.
     */
    protected function initializeNodeListDiffer(): void {
        if (isset($this-&gt;nodeListDiffer)) {
            return;
        }

        $this-&gt;nodeListDiffer = new Internal\Differ(function ($a, $b) {
            if ($a instanceof Node &amp;&amp; $b instanceof Node) {
                return $a === $b-&gt;getAttribute('origNode');
            }
            // Can happen for array destructuring
            return $a === null &amp;&amp; $b === null;
        });
    }

    /**
     * Lazily initializes fixup map.
     *
     * The fixup map is used to determine whether a certain subnode of a certain node may require
     * some kind of &quot;fixup&quot; operation, e.g. the addition of parenthesis or braces.
     */
    protected function initializeFixupMap(): void {
        if (isset($this-&gt;fixupMap)) {
            return;
        }

        $this-&gt;fixupMap = [
            Expr\Instanceof_::class =&gt; [
                'expr' =&gt; self::FIXUP_PREC_UNARY,
                'class' =&gt; self::FIXUP_NEW,
            ],
            Expr\Ternary::class =&gt; [
                'cond' =&gt; self::FIXUP_PREC_LEFT,
                'else' =&gt; self::FIXUP_PREC_RIGHT,
            ],
            Expr\Yield_::class =&gt; ['value' =&gt; self::FIXUP_PREC_UNARY],

            Expr\FuncCall::class =&gt; ['name' =&gt; self::FIXUP_CALL_LHS],
            Expr\StaticCall::class =&gt; ['class' =&gt; self::FIXUP_STATIC_DEREF_LHS],
            Expr\ArrayDimFetch::class =&gt; ['var' =&gt; self::FIXUP_DEREF_LHS],
            Expr\ClassConstFetch::class =&gt; [
                'class' =&gt; self::FIXUP_STATIC_DEREF_LHS,
                'name' =&gt; self::FIXUP_BRACED_NAME,
            ],
            Expr\New_::class =&gt; ['class' =&gt; self::FIXUP_NEW],
            Expr\MethodCall::class =&gt; [
                'var' =&gt; self::FIXUP_DEREF_LHS,
                'name' =&gt; self::FIXUP_BRACED_NAME,
            ],
            Expr\NullsafeMethodCall::class =&gt; [
                'var' =&gt; self::FIXUP_DEREF_LHS,
                'name' =&gt; self::FIXUP_BRACED_NAME,
            ],
            Expr\StaticPropertyFetch::class =&gt; [
                'class' =&gt; self::FIXUP_STATIC_DEREF_LHS,
                'name' =&gt; self::FIXUP_VAR_BRACED_NAME,
            ],
            Expr\PropertyFetch::class =&gt; [
                'var' =&gt; self::FIXUP_DEREF_LHS,
                'name' =&gt; self::FIXUP_BRACED_NAME,
            ],
            Expr\NullsafePropertyFetch::class =&gt; [
                'var' =&gt; self::FIXUP_DEREF_LHS,
                'name' =&gt; self::FIXUP_BRACED_NAME,
            ],
            Scalar\InterpolatedString::class =&gt; [
                'parts' =&gt; self::FIXUP_ENCAPSED,
            ],
        ];

        $binaryOps = [
            BinaryOp\Pow::class, BinaryOp\Mul::class, BinaryOp\Div::class, BinaryOp\Mod::class,
            BinaryOp\Plus::class, BinaryOp\Minus::class, BinaryOp\Concat::class,
            BinaryOp\ShiftLeft::class, BinaryOp\ShiftRight::class, BinaryOp\Smaller::class,
            BinaryOp\SmallerOrEqual::class, BinaryOp\Greater::class, BinaryOp\GreaterOrEqual::class,
            BinaryOp\Equal::class, BinaryOp\NotEqual::class, BinaryOp\Identical::class,
            BinaryOp\NotIdentical::class, BinaryOp\Spaceship::class, BinaryOp\BitwiseAnd::class,
            BinaryOp\BitwiseXor::class, BinaryOp\BitwiseOr::class, BinaryOp\BooleanAnd::class,
            BinaryOp\BooleanOr::class, BinaryOp\Coalesce::class, BinaryOp\LogicalAnd::class,
            BinaryOp\LogicalXor::class, BinaryOp\LogicalOr::class,
        ];
        foreach ($binaryOps as $binaryOp) {
            $this-&gt;fixupMap[$binaryOp] = [
                'left' =&gt; self::FIXUP_PREC_LEFT,
                'right' =&gt; self::FIXUP_PREC_RIGHT
            ];
        }

        $prefixOps = [
            Expr\Clone_::class, Expr\BitwiseNot::class, Expr\BooleanNot::class, Expr\UnaryPlus::class, Expr\UnaryMinus::class,
            Cast\Int_::class, Cast\Double::class, Cast\String_::class, Cast\Array_::class,
            Cast\Object_::class, Cast\Bool_::class, Cast\Unset_::class, Expr\ErrorSuppress::class,
            Expr\YieldFrom::class, Expr\Print_::class, Expr\Include_::class,
            Expr\Assign::class, Expr\AssignRef::class, AssignOp\Plus::class, AssignOp\Minus::class,
            AssignOp\Mul::class, AssignOp\Div::class, AssignOp\Concat::class, AssignOp\Mod::class,
            AssignOp\BitwiseAnd::class, AssignOp\BitwiseOr::class, AssignOp\BitwiseXor::class,
            AssignOp\ShiftLeft::class, AssignOp\ShiftRight::class, AssignOp\Pow::class, AssignOp\Coalesce::class,
            Expr\ArrowFunction::class, Expr\Throw_::class,
        ];
        foreach ($prefixOps as $prefixOp) {
            $this-&gt;fixupMap[$prefixOp] = ['expr' =&gt; self::FIXUP_PREC_UNARY];
        }
    }

    /**
     * Lazily initializes the removal map.
     *
     * The removal map is used to determine which additional tokens should be removed when a
     * certain node is replaced by null.
     */
    protected function initializeRemovalMap(): void {
        if (isset($this-&gt;removalMap)) {
            return;
        }

        $stripBoth = ['left' =&gt; \T_WHITESPACE, 'right' =&gt; \T_WHITESPACE];
        $stripLeft = ['left' =&gt; \T_WHITESPACE];
        $stripRight = ['right' =&gt; \T_WHITESPACE];
        $stripDoubleArrow = ['right' =&gt; \T_DOUBLE_ARROW];
        $stripColon = ['left' =&gt; ':'];
        $stripEquals = ['left' =&gt; '='];
        $this-&gt;removalMap = [
            'Expr_ArrayDimFetch-&gt;dim' =&gt; $stripBoth,
            'ArrayItem-&gt;key' =&gt; $stripDoubleArrow,
            'Expr_ArrowFunction-&gt;returnType' =&gt; $stripColon,
            'Expr_Closure-&gt;returnType' =&gt; $stripColon,
            'Expr_Exit-&gt;expr' =&gt; $stripBoth,
            'Expr_Ternary-&gt;if' =&gt; $stripBoth,
            'Expr_Yield-&gt;key' =&gt; $stripDoubleArrow,
            'Expr_Yield-&gt;value' =&gt; $stripBoth,
            'Param-&gt;type' =&gt; $stripRight,
            'Param-&gt;default' =&gt; $stripEquals,
            'Stmt_Break-&gt;num' =&gt; $stripBoth,
            'Stmt_Catch-&gt;var' =&gt; $stripLeft,
            'Stmt_ClassConst-&gt;type' =&gt; $stripRight,
            'Stmt_ClassMethod-&gt;returnType' =&gt; $stripColon,
            'Stmt_Class-&gt;extends' =&gt; ['left' =&gt; \T_EXTENDS],
            'Stmt_Enum-&gt;scalarType' =&gt; $stripColon,
            'Stmt_EnumCase-&gt;expr' =&gt; $stripEquals,
            'Expr_PrintableNewAnonClass-&gt;extends' =&gt; ['left' =&gt; \T_EXTENDS],
            'Stmt_Continue-&gt;num' =&gt; $stripBoth,
            'Stmt_Foreach-&gt;keyVar' =&gt; $stripDoubleArrow,
            'Stmt_Function-&gt;returnType' =&gt; $stripColon,
            'Stmt_If-&gt;else' =&gt; $stripLeft,
            'Stmt_Namespace-&gt;name' =&gt; $stripLeft,
            'Stmt_Property-&gt;type' =&gt; $stripRight,
            'PropertyItem-&gt;default' =&gt; $stripEquals,
            'Stmt_Return-&gt;expr' =&gt; $stripBoth,
            'Stmt_StaticVar-&gt;default' =&gt; $stripEquals,
            'Stmt_TraitUseAdaptation_Alias-&gt;newName' =&gt; $stripLeft,
            'Stmt_TryCatch-&gt;finally' =&gt; $stripLeft,
            // 'Stmt_Case-&gt;cond': Replace with &quot;default&quot;
            // 'Stmt_Class-&gt;name': Unclear what to do
            // 'Stmt_Declare-&gt;stmts': Not a plain node
            // 'Stmt_TraitUseAdaptation_Alias-&gt;newModifier': Not a plain node
        ];
    }

    protected function initializeInsertionMap(): void {
        if (isset($this-&gt;insertionMap)) {
            return;
        }

        // TODO: &quot;yield&quot; where both key and value are inserted doesn't work
        // [$find, $beforeToken, $extraLeft, $extraRight]
        $this-&gt;insertionMap = [
            'Expr_ArrayDimFetch-&gt;dim' =&gt; ['[', false, null, null],
            'ArrayItem-&gt;key' =&gt; [null, false, null, ' =&gt; '],
            'Expr_ArrowFunction-&gt;returnType' =&gt; [')', false, ': ', null],
            'Expr_Closure-&gt;returnType' =&gt; [')', false, ': ', null],
            'Expr_Ternary-&gt;if' =&gt; ['?', false, ' ', ' '],
            'Expr_Yield-&gt;key' =&gt; [\T_YIELD, false, null, ' =&gt; '],
            'Expr_Yield-&gt;value' =&gt; [\T_YIELD, false, ' ', null],
            'Param-&gt;type' =&gt; [null, false, null, ' '],
            'Param-&gt;default' =&gt; [null, false, ' = ', null],
            'Stmt_Break-&gt;num' =&gt; [\T_BREAK, false, ' ', null],
            'Stmt_Catch-&gt;var' =&gt; [null, false, ' ', null],
            'Stmt_ClassMethod-&gt;returnType' =&gt; [')', false, ': ', null],
            'Stmt_ClassConst-&gt;type' =&gt; [\T_CONST, false, ' ', null],
            'Stmt_Class-&gt;extends' =&gt; [null, false, ' extends ', null],
            'Stmt_Enum-&gt;scalarType' =&gt; [null, false, ' : ', null],
            'Stmt_EnumCase-&gt;expr' =&gt; [null, false, ' = ', null],
            'Expr_PrintableNewAnonClass-&gt;extends' =&gt; [null, false, ' extends ', null],
            'Stmt_Continue-&gt;num' =&gt; [\T_CONTINUE, false, ' ', null],
            'Stmt_Foreach-&gt;keyVar' =&gt; [\T_AS, false, null, ' =&gt; '],
            'Stmt_Function-&gt;returnType' =&gt; [')', false, ': ', null],
            'Stmt_If-&gt;else' =&gt; [null, false, ' ', null],
            'Stmt_Namespace-&gt;name' =&gt; [\T_NAMESPACE, false, ' ', null],
            'Stmt_Property-&gt;type' =&gt; [\T_VARIABLE, true, null, ' '],
            'PropertyItem-&gt;default' =&gt; [null, false, ' = ', null],
            'Stmt_Return-&gt;expr' =&gt; [\T_RETURN, false, ' ', null],
            'Stmt_StaticVar-&gt;default' =&gt; [null, false, ' = ', null],
            //'Stmt_TraitUseAdaptation_Alias-&gt;newName' =&gt; [T_AS, false, ' ', null], // TODO
            'Stmt_TryCatch-&gt;finally' =&gt; [null, false, ' ', null],

            // 'Expr_Exit-&gt;expr': Complicated due to optional ()
            // 'Stmt_Case-&gt;cond': Conversion from default to case
            // 'Stmt_Class-&gt;name': Unclear
            // 'Stmt_Declare-&gt;stmts': Not a proper node
            // 'Stmt_TraitUseAdaptation_Alias-&gt;newModifier': Not a proper node
        ];
    }

    protected function initializeListInsertionMap(): void {
        if (isset($this-&gt;listInsertionMap)) {
            return;
        }

        $this-&gt;listInsertionMap = [
            // special
            //'Expr_ShellExec-&gt;parts' =&gt; '', // TODO These need to be treated more carefully
            //'Scalar_InterpolatedString-&gt;parts' =&gt; '',
            Stmt\Catch_::class . '-&gt;types' =&gt; '|',
            UnionType::class . '-&gt;types' =&gt; '|',
            IntersectionType::class . '-&gt;types' =&gt; '&amp;',
            Stmt\If_::class . '-&gt;elseifs' =&gt; ' ',
            Stmt\TryCatch::class . '-&gt;catches' =&gt; ' ',

            // comma-separated lists
            Expr\Array_::class . '-&gt;items' =&gt; ', ',
            Expr\ArrowFunction::class . '-&gt;params' =&gt; ', ',
            Expr\Closure::class . '-&gt;params' =&gt; ', ',
            Expr\Closure::class . '-&gt;uses' =&gt; ', ',
            Expr\FuncCall::class . '-&gt;args' =&gt; ', ',
            Expr\Isset_::class . '-&gt;vars' =&gt; ', ',
            Expr\List_::class . '-&gt;items' =&gt; ', ',
            Expr\MethodCall::class . '-&gt;args' =&gt; ', ',
            Expr\NullsafeMethodCall::class . '-&gt;args' =&gt; ', ',
            Expr\New_::class . '-&gt;args' =&gt; ', ',
            PrintableNewAnonClassNode::class . '-&gt;args' =&gt; ', ',
            Expr\StaticCall::class . '-&gt;args' =&gt; ', ',
            Stmt\ClassConst::class . '-&gt;consts' =&gt; ', ',
            Stmt\ClassMethod::class . '-&gt;params' =&gt; ', ',
            Stmt\Class_::class . '-&gt;implements' =&gt; ', ',
            Stmt\Enum_::class . '-&gt;implements' =&gt; ', ',
            PrintableNewAnonClassNode::class . '-&gt;implements' =&gt; ', ',
            Stmt\Const_::class . '-&gt;consts' =&gt; ', ',
            Stmt\Declare_::class . '-&gt;declares' =&gt; ', ',
            Stmt\Echo_::class . '-&gt;exprs' =&gt; ', ',
            Stmt\For_::class . '-&gt;init' =&gt; ', ',
            Stmt\For_::class . '-&gt;cond' =&gt; ', ',
            Stmt\For_::class . '-&gt;loop' =&gt; ', ',
            Stmt\Function_::class . '-&gt;params' =&gt; ', ',
            Stmt\Global_::class . '-&gt;vars' =&gt; ', ',
            Stmt\GroupUse::class . '-&gt;uses' =&gt; ', ',
            Stmt\Interface_::class . '-&gt;extends' =&gt; ', ',
            Expr\Match_::class . '-&gt;arms' =&gt; ', ',
            Stmt\Property::class . '-&gt;props' =&gt; ', ',
            Stmt\StaticVar::class . '-&gt;vars' =&gt; ', ',
            Stmt\TraitUse::class . '-&gt;traits' =&gt; ', ',
            Stmt\TraitUseAdaptation\Precedence::class . '-&gt;insteadof' =&gt; ', ',
            Stmt\Unset_::class .  '-&gt;vars' =&gt; ', ',
            Stmt\UseUse::class . '-&gt;uses' =&gt; ', ',
            MatchArm::class . '-&gt;conds' =&gt; ', ',
            AttributeGroup::class . '-&gt;attrs' =&gt; ', ',

            // statement lists
            Expr\Closure::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Case_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Catch_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Class_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Enum_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            PrintableNewAnonClassNode::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Interface_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Trait_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\ClassMethod::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Declare_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Do_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\ElseIf_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Else_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Finally_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Foreach_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\For_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Function_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\If_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Namespace_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\Block::class . '-&gt;stmts' =&gt; &quot;\n&quot;,

            // Attribute groups
            Stmt\Class_::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\Enum_::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\EnumCase::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\Interface_::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\Trait_::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\Function_::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\ClassMethod::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\ClassConst::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            Stmt\Property::class . '-&gt;attrGroups' =&gt; &quot;\n&quot;,
            PrintableNewAnonClassNode::class . '-&gt;attrGroups' =&gt; ' ',
            Expr\Closure::class . '-&gt;attrGroups' =&gt; ' ',
            Expr\ArrowFunction::class . '-&gt;attrGroups' =&gt; ' ',
            Param::class . '-&gt;attrGroups' =&gt; ' ',
            Stmt\Switch_::class . '-&gt;cases' =&gt; &quot;\n&quot;,
            Stmt\TraitUse::class . '-&gt;adaptations' =&gt; &quot;\n&quot;,
            Stmt\TryCatch::class . '-&gt;stmts' =&gt; &quot;\n&quot;,
            Stmt\While_::class . '-&gt;stmts' =&gt; &quot;\n&quot;,

            // dummy for top-level context
            'File-&gt;stmts' =&gt; &quot;\n&quot;,
        ];
    }

    protected function initializeEmptyListInsertionMap(): void {
        if (isset($this-&gt;emptyListInsertionMap)) {
            return;
        }

        // TODO Insertion into empty statement lists.

        // [$find, $extraLeft, $extraRight]
        $this-&gt;emptyListInsertionMap = [
            Expr\ArrowFunction::class . '-&gt;params' =&gt; ['(', '', ''],
            Expr\Closure::class . '-&gt;uses' =&gt; [')', ' use (', ')'],
            Expr\Closure::class . '-&gt;params' =&gt; ['(', '', ''],
            Expr\FuncCall::class . '-&gt;args' =&gt; ['(', '', ''],
            Expr\MethodCall::class . '-&gt;args' =&gt; ['(', '', ''],
            Expr\NullsafeMethodCall::class . '-&gt;args' =&gt; ['(', '', ''],
            Expr\New_::class . '-&gt;args' =&gt; ['(', '', ''],
            PrintableNewAnonClassNode::class . '-&gt;args' =&gt; ['(', '', ''],
            PrintableNewAnonClassNode::class . '-&gt;implements' =&gt; [null, ' implements ', ''],
            Expr\StaticCall::class . '-&gt;args' =&gt; ['(', '', ''],
            Stmt\Class_::class . '-&gt;implements' =&gt; [null, ' implements ', ''],
            Stmt\Enum_::class . '-&gt;implements' =&gt; [null, ' implements ', ''],
            Stmt\ClassMethod::class . '-&gt;params' =&gt; ['(', '', ''],
            Stmt\Interface_::class . '-&gt;extends' =&gt; [null, ' extends ', ''],
            Stmt\Function_::class . '-&gt;params' =&gt; ['(', '', ''],
            Stmt\Interface_::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Stmt\Class_::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Stmt\ClassConst::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Stmt\ClassMethod::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Stmt\Function_::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Stmt\Property::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Stmt\Trait_::class . '-&gt;attrGroups' =&gt; [null, '', &quot;\n&quot;],
            Expr\ArrowFunction::class . '-&gt;attrGroups' =&gt; [null, '', ' '],
            Expr\Closure::class . '-&gt;attrGroups' =&gt; [null, '', ' '],
            PrintableNewAnonClassNode::class . '-&gt;attrGroups' =&gt; [\T_NEW, ' ', ''],

            /* These cannot be empty to start with:
             * Expr_Isset-&gt;vars
             * Stmt_Catch-&gt;types
             * Stmt_Const-&gt;consts
             * Stmt_ClassConst-&gt;consts
             * Stmt_Declare-&gt;declares
             * Stmt_Echo-&gt;exprs
             * Stmt_Global-&gt;vars
             * Stmt_GroupUse-&gt;uses
             * Stmt_Property-&gt;props
             * Stmt_StaticVar-&gt;vars
             * Stmt_TraitUse-&gt;traits
             * Stmt_TraitUseAdaptation_Precedence-&gt;insteadof
             * Stmt_Unset-&gt;vars
             * Stmt_Use-&gt;uses
             * UnionType-&gt;types
             */

            /* TODO
             * Stmt_If-&gt;elseifs
             * Stmt_TryCatch-&gt;catches
             * Expr_Array-&gt;items
             * Expr_List-&gt;items
             * Stmt_For-&gt;init
             * Stmt_For-&gt;cond
             * Stmt_For-&gt;loop
             */
        ];
    }

    protected function initializeModifierChangeMap(): void {
        if (isset($this-&gt;modifierChangeMap)) {
            return;
        }

        $this-&gt;modifierChangeMap = [
            Stmt\ClassConst::class . '-&gt;flags' =&gt; ['pModifiers', \T_CONST],
            Stmt\ClassMethod::class . '-&gt;flags' =&gt; ['pModifiers', \T_FUNCTION],
            Stmt\Class_::class . '-&gt;flags' =&gt; ['pModifiers', \T_CLASS],
            Stmt\Property::class . '-&gt;flags' =&gt; ['pModifiers', \T_VARIABLE],
            PrintableNewAnonClassNode::class . '-&gt;flags' =&gt; ['pModifiers', \T_CLASS],
            Param::class . '-&gt;flags' =&gt; ['pModifiers', \T_VARIABLE],
            Expr\Closure::class . '-&gt;static' =&gt; ['pStatic', \T_FUNCTION],
            Expr\ArrowFunction::class . '-&gt;static' =&gt; ['pStatic', \T_FN],
            //Stmt\TraitUseAdaptation\Alias::class . '-&gt;newModifier' =&gt; 0, // TODO
        ];

        // List of integer subnodes that are not modifiers:
        // Expr_Include-&gt;type
        // Stmt_GroupUse-&gt;type
        // Stmt_Use-&gt;type
        // UseItem-&gt;type
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>