@appthreat/atom-parsetools 1.0.3 → 1.0.5

package/plugins/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php

@@ -3,162 +3,223 @@
 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\PropertyHook;
 use PhpParser\Node\Scalar;
 use PhpParser\Node\Stmt;
-
-abstract class PrettyPrinterAbstract
-{
-    const FIXUP_PREC_LEFT       = 0; // LHS operand affected by precedence
-    const FIXUP_PREC_RIGHT      = 1; // RHS operand affected by precedence
-    const FIXUP_CALL_LHS        = 2; // LHS of call
-    const FIXUP_DEREF_LHS       = 3; // LHS of dereferencing operation
-    const FIXUP_BRACED_NAME     = 4; // Name operand that may require bracing
-    const FIXUP_VAR_BRACED_NAME = 5; // Name operand that may require ${} bracing
-    const FIXUP_ENCAPSED        = 6; // Encapsed string part
-    const FIXUP_NEW             = 7; // New/instanceof operand
-    const FIXUP_STATIC_DEREF_LHS = 8; // LHS of static dereferencing operation
-
-    protected $precedenceMap = [
-        // [precedence, associativity]
-        // where for precedence -1 is %left, 0 is %nonassoc and 1 is %right
-        BinaryOp\Pow::class            => [  0,  1],
-        Expr\BitwiseNot::class         => [ 10,  1],
-        Expr\PreInc::class             => [ 10,  1],
-        Expr\PreDec::class             => [ 10,  1],
-        Expr\PostInc::class            => [ 10, -1],
-        Expr\PostDec::class            => [ 10, -1],
-        Expr\UnaryPlus::class          => [ 10,  1],
-        Expr\UnaryMinus::class         => [ 10,  1],
-        Cast\Int_::class               => [ 10,  1],
-        Cast\Double::class             => [ 10,  1],
-        Cast\String_::class            => [ 10,  1],
-        Cast\Array_::class             => [ 10,  1],
-        Cast\Object_::class            => [ 10,  1],
-        Cast\Bool_::class              => [ 10,  1],
-        Cast\Unset_::class             => [ 10,  1],
-        Expr\ErrorSuppress::class      => [ 10,  1],
-        Expr\Instanceof_::class        => [ 20,  0],
-        Expr\BooleanNot::class         => [ 30,  1],
-        BinaryOp\Mul::class            => [ 40, -1],
-        BinaryOp\Div::class            => [ 40, -1],
-        BinaryOp\Mod::class            => [ 40, -1],
-        BinaryOp\Plus::class           => [ 50, -1],
-        BinaryOp\Minus::class          => [ 50, -1],
-        BinaryOp\Concat::class         => [ 50, -1],
-        BinaryOp\ShiftLeft::class      => [ 60, -1],
-        BinaryOp\ShiftRight::class     => [ 60, -1],
-        BinaryOp\Smaller::class        => [ 70,  0],
-        BinaryOp\SmallerOrEqual::class => [ 70,  0],
-        BinaryOp\Greater::class        => [ 70,  0],
-        BinaryOp\GreaterOrEqual::class => [ 70,  0],
-        BinaryOp\Equal::class          => [ 80,  0],
-        BinaryOp\NotEqual::class       => [ 80,  0],
-        BinaryOp\Identical::class      => [ 80,  0],
-        BinaryOp\NotIdentical::class   => [ 80,  0],
-        BinaryOp\Spaceship::class      => [ 80,  0],
-        BinaryOp\BitwiseAnd::class     => [ 90, -1],
-        BinaryOp\BitwiseXor::class     => [100, -1],
-        BinaryOp\BitwiseOr::class      => [110, -1],
-        BinaryOp\BooleanAnd::class     => [120, -1],
-        BinaryOp\BooleanOr::class      => [130, -1],
-        BinaryOp\Coalesce::class       => [140,  1],
-        Expr\Ternary::class            => [150,  0],
-        // parser uses %left for assignments, but they really behave as %right
-        Expr\Assign::class             => [160,  1],
-        Expr\AssignRef::class          => [160,  1],
-        AssignOp\Plus::class           => [160,  1],
-        AssignOp\Minus::class          => [160,  1],
-        AssignOp\Mul::class            => [160,  1],
-        AssignOp\Div::class            => [160,  1],
-        AssignOp\Concat::class         => [160,  1],
-        AssignOp\Mod::class            => [160,  1],
-        AssignOp\BitwiseAnd::class     => [160,  1],
-        AssignOp\BitwiseOr::class      => [160,  1],
-        AssignOp\BitwiseXor::class     => [160,  1],
-        AssignOp\ShiftLeft::class      => [160,  1],
-        AssignOp\ShiftRight::class     => [160,  1],
-        AssignOp\Pow::class            => [160,  1],
-        AssignOp\Coalesce::class       => [160,  1],
-        Expr\YieldFrom::class          => [165,  1],
-        Expr\Print_::class             => [168,  1],
-        BinaryOp\LogicalAnd::class     => [170, -1],
-        BinaryOp\LogicalXor::class     => [180, -1],
-        BinaryOp\LogicalOr::class      => [190, -1],
-        Expr\Include_::class           => [200, -1],
+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<class-string, array{int, int, int}> */
+    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             => [-10,   0,   1],
+        BinaryOp\Pow::class            => [  0,   0,   1],
+        Expr\BitwiseNot::class         => [ 10,  -1,  -1],
+        Expr\UnaryPlus::class          => [ 10,  -1,  -1],
+        Expr\UnaryMinus::class         => [ 10,  -1,  -1],
+        Cast\Int_::class               => [ 10,  -1,  -1],
+        Cast\Double::class             => [ 10,  -1,  -1],
+        Cast\String_::class            => [ 10,  -1,  -1],
+        Cast\Array_::class             => [ 10,  -1,  -1],
+        Cast\Object_::class            => [ 10,  -1,  -1],
+        Cast\Bool_::class              => [ 10,  -1,  -1],
+        Cast\Unset_::class             => [ 10,  -1,  -1],
+        Expr\ErrorSuppress::class      => [ 10,  -1,  -1],
+        Expr\Instanceof_::class        => [ 20,  -1,  -1],
+        Expr\BooleanNot::class         => [ 30,  -1,  -1],
+        BinaryOp\Mul::class            => [ 40,  41,  40],
+        BinaryOp\Div::class            => [ 40,  41,  40],
+        BinaryOp\Mod::class            => [ 40,  41,  40],
+        BinaryOp\Plus::class           => [ 50,  51,  50],
+        BinaryOp\Minus::class          => [ 50,  51,  50],
+        BinaryOp\Concat::class         => [ 50,  51,  50],
+        BinaryOp\ShiftLeft::class      => [ 60,  61,  60],
+        BinaryOp\ShiftRight::class     => [ 60,  61,  60],
+        BinaryOp\Smaller::class        => [ 70,  70,  70],
+        BinaryOp\SmallerOrEqual::class => [ 70,  70,  70],
+        BinaryOp\Greater::class        => [ 70,  70,  70],
+        BinaryOp\GreaterOrEqual::class => [ 70,  70,  70],
+        BinaryOp\Equal::class          => [ 80,  80,  80],
+        BinaryOp\NotEqual::class       => [ 80,  80,  80],
+        BinaryOp\Identical::class      => [ 80,  80,  80],
+        BinaryOp\NotIdentical::class   => [ 80,  80,  80],
+        BinaryOp\Spaceship::class      => [ 80,  80,  80],
+        BinaryOp\BitwiseAnd::class     => [ 90,  91,  90],
+        BinaryOp\BitwiseXor::class     => [100, 101, 100],
+        BinaryOp\BitwiseOr::class      => [110, 111, 110],
+        BinaryOp\BooleanAnd::class     => [120, 121, 120],
+        BinaryOp\BooleanOr::class      => [130, 131, 130],
+        BinaryOp\Coalesce::class       => [140, 140, 141],
+        Expr\Ternary::class            => [150, 150, 150],
+        Expr\Assign::class             => [160,  -1,  -1],
+        Expr\AssignRef::class          => [160,  -1,  -1],
+        AssignOp\Plus::class           => [160,  -1,  -1],
+        AssignOp\Minus::class          => [160,  -1,  -1],
+        AssignOp\Mul::class            => [160,  -1,  -1],
+        AssignOp\Div::class            => [160,  -1,  -1],
+        AssignOp\Concat::class         => [160,  -1,  -1],
+        AssignOp\Mod::class            => [160,  -1,  -1],
+        AssignOp\BitwiseAnd::class     => [160,  -1,  -1],
+        AssignOp\BitwiseOr::class      => [160,  -1,  -1],
+        AssignOp\BitwiseXor::class     => [160,  -1,  -1],
+        AssignOp\ShiftLeft::class      => [160,  -1,  -1],
+        AssignOp\ShiftRight::class     => [160,  -1,  -1],
+        AssignOp\Pow::class            => [160,  -1,  -1],
+        AssignOp\Coalesce::class       => [160,  -1,  -1],
+        Expr\YieldFrom::class          => [170,  -1,  -1],
+        Expr\Yield_::class             => [175,  -1,  -1],
+        Expr\Print_::class             => [180,  -1,  -1],
+        BinaryOp\LogicalAnd::class     => [190, 191, 190],
+        BinaryOp\LogicalXor::class     => [200, 201, 200],
+        BinaryOp\LogicalOr::class      => [210, 211, 210],
+        Expr\Include_::class           => [220,  -1,  -1],
+        Expr\ArrowFunction::class      => [230,  -1,  -1],
+        Expr\Throw_::class             => [240,  -1,  -1],
     ];
 
     /** @var int Current indentation level. */
-    protected $indentLevel;
+    protected int $indentLevel;
+    /** @var string String for single level of indentation */
+    private string $indent;
+    /** @var int Width in spaces to indent by. */
+    private int $indentWidth;
+    /** @var bool Whether to use tab indentation. */
+    private bool $useTabs;
+    /** @var int Width in spaces of one tab. */
+    private int $tabWidth = 4;
+
+    /** @var string Newline style. Does not include current indentation. */
+    protected string $newline;
     /** @var string Newline including current indentation. */
-    protected $nl;
-    /** @var string Token placed at end of doc string to ensure it is followed by a newline. */
-    protected $docStringEndToken;
+    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 $canUseSemicolonNamespaces;
-    /** @var array Pretty printer options */
-    protected $options;
-
-    /** @var TokenStream Original tokens for use in format-preserving pretty print */
-    protected $origTokens;
-    /** @var Internal\Differ Differ for node lists */
-    protected $nodeListDiffer;
-    /** @var bool[] Map determining whether a certain character is a label character */
-    protected $labelCharMap;
+    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<Node> Differ for node lists */
+    protected Differ $nodeListDiffer;
+    /** @var array<string, bool> Map determining whether a certain character is a label character */
+    protected array $labelCharMap;
     /**
-     * @var int[][] Map from token classes and subnode names to FIXUP_* constants. This is used
-     *              during format-preserving prints to place additional parens/braces if necessary.
+     * @var array<string, array<string, int>> 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 $fixupMap;
+    protected array $fixupMap;
     /**
-     * @var int[][] Map from "{$node->getType()}->{$subNode}" to ['left' => $l, 'right' => $r],
-     *              where $l and $r specify the token type that needs to be stripped when removing
-     *              this node.
+     * @var array<string, array{left?: int|string, right?: int|string}> Map from "{$node->getType()}->{$subNode}"
+     *                                                                  to ['left' => $l, 'right' => $r], where $l and $r specify the token type that needs to be stripped
+     *                                                                  when removing this node.
      */
-    protected $removalMap;
+    protected array $removalMap;
     /**
-     * @var mixed[] Map from "{$node->getType()}->{$subNode}" 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.
+     * @var array<string, array{int|string|null, bool, string|null, string|null}> Map from
+     *                                                                            "{$node->getType()}->{$subNode}" 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 $insertionMap;
+    protected array $insertionMap;
     /**
-     * @var string[] Map From "{$node->getType()}->{$subNode}" to string that should be inserted
-     *               between elements of this list subnode.
+     * @var array<string, string> Map From "{$class}->{$subNode}" to string that should be inserted
+     *                            between elements of this list subnode.
      */
-    protected $listInsertionMap;
-    protected $emptyListInsertionMap;
-    /** @var int[] Map from "{$node->getType()}->{$subNode}" to token before which the modifiers
-     *             should be reprinted. */
-    protected $modifierChangeMap;
+    protected array $listInsertionMap;
+
+    /**
+     * @var array<string, array{int|string|null, string, string}>
+     */
+    protected array $emptyListInsertionMap;
+    /** @var array<string, array{string, int}> Map from "{$class}->{$subNode}" 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:
-     *  * bool $shortArraySyntax = false: Whether to use [] instead of array() as the default array
-     *                                    syntax, if the node does not specify a format.
+     *  * 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 "\n" (default) or "\r\n".
+     *  * string $indent:         The indentation to use. Should either be all spaces or a single
+     *                            tab. Defaults to four spaces ("    ").
+     *  * 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 $options Dictionary of formatting options
+     * @param array{
+     *     phpVersion?: PhpVersion, newline?: string, indent?: string, shortArraySyntax?: bool
+     * } $options Dictionary of formatting options
      */
     public function __construct(array $options = []) {
-        $this->docStringEndToken = '_DOC_STRING_END_' . mt_rand();
+        $this->phpVersion = $options['phpVersion'] ?? PhpVersion::fromComponents(7, 4);
+
+        $this->newline = $options['newline'] ?? "\n";
+        if ($this->newline !== "\n" && $this->newline != "\r\n") {
+            throw new \LogicException('Option "newline" must be one of "\n" or "\r\n"');
+        }
 
-        $defaultOptions = ['shortArraySyntax' => false];
-        $this->options = $options + $defaultOptions;
+        $this->shortArraySyntax =
+            $options['shortArraySyntax'] ?? $this->phpVersion->supportsShortArraySyntax();
+        $this->docStringEndToken =
+            $this->phpVersion->supportsFlexibleHeredoc() ? null : '_DOC_STRING_END_' . mt_rand();
+
+        $this->indent = $indent = $options['indent'] ?? '    ';
+        if ($indent === "\t") {
+            $this->useTabs = true;
+            $this->indentWidth = $this->tabWidth;
+        } elseif ($indent === \str_repeat(' ', \strlen($indent))) {
+            $this->useTabs = false;
+            $this->indentWidth = \strlen($indent);
+        } else {
+            throw new \LogicException('Option "indent" must either be all spaces or a single tab');
+        }
     }
 
     /**
      * Reset pretty printing state.
      */
-    protected function resetState() {
+    protected function resetState(): void {
         $this->indentLevel = 0;
-        $this->nl = "\n";
+        $this->nl = $this->newline;
         $this->origTokens = null;
     }
 
@@ -167,26 +228,31 @@ abstract class PrettyPrinterAbstract
      *
      * @param int $level Level in number of spaces
      */
-    protected function setIndentLevel(int $level) {
+    protected function setIndentLevel(int $level): void {
         $this->indentLevel = $level;
-        $this->nl = "\n" . \str_repeat(' ', $level);
+        if ($this->useTabs) {
+            $tabs = \intdiv($level, $this->tabWidth);
+            $spaces = $level % $this->tabWidth;
+            $this->nl = $this->newline . \str_repeat("\t", $tabs) . \str_repeat(' ', $spaces);
+        } else {
+            $this->nl = $this->newline . \str_repeat(' ', $level);
+        }
     }
 
     /**
      * Increase indentation level.
      */
-    protected function indent() {
-        $this->indentLevel += 4;
-        $this->nl .= '    ';
+    protected function indent(): void {
+        $this->indentLevel += $this->indentWidth;
+        $this->nl .= $this->indent;
     }
 
     /**
      * Decrease indentation level.
      */
-    protected function outdent() {
-        assert($this->indentLevel >= 4);
-        $this->indentLevel -= 4;
-        $this->nl = "\n" . str_repeat(' ', $this->indentLevel);
+    protected function outdent(): void {
+        assert($this->indentLevel >= $this->indentWidth);
+        $this->setIndentLevel($this->indentLevel - $this->indentWidth);
     }
 
     /**
@@ -196,7 +262,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return string Pretty printed statements
      */
-    public function prettyPrint(array $stmts) : string {
+    public function prettyPrint(array $stmts): string {
         $this->resetState();
         $this->preprocessNodes($stmts);
 
@@ -210,7 +276,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return string Pretty printed node
      */
-    public function prettyPrintExpr(Expr $node) : string {
+    public function prettyPrintExpr(Expr $node): string {
         $this->resetState();
         return $this->handleMagicTokens($this->p($node));
     }
@@ -222,15 +288,15 @@ abstract class PrettyPrinterAbstract
      *
      * @return string Pretty printed statements
      */
-    public function prettyPrintFile(array $stmts) : string {
+    public function prettyPrintFile(array $stmts): string {
         if (!$stmts) {
-            return "<?php\n\n";
+            return "<?php" . $this->newline . $this->newline;
         }
 
-        $p = "<?php\n\n" . $this->prettyPrint($stmts);
+        $p = "<?php" . $this->newline . $this->newline . $this->prettyPrint($stmts);
 
         if ($stmts[0] instanceof Stmt\InlineHTML) {
-            $p = preg_replace('/^<\?php\s+\?>\n?/', '', $p);
+            $p = preg_replace('/^<\?php\s+\?>\r?\n?/', '', $p);
         }
         if ($stmts[count($stmts) - 1] instanceof Stmt\InlineHTML) {
             $p = preg_replace('/<\?php$/', '', rtrim($p));
@@ -244,7 +310,7 @@ abstract class PrettyPrinterAbstract
      *
      * @param Node[] $nodes Array of nodes
      */
-    protected function preprocessNodes(array $nodes) {
+    protected function preprocessNodes(array $nodes): void {
         /* We can use semicolon-namespaces unless there is a global namespace declaration */
         $this->canUseSemicolonNamespaces = true;
         foreach ($nodes as $node) {
@@ -256,15 +322,17 @@ abstract class PrettyPrinterAbstract
     }
 
     /**
-     * Handles (and removes) no-indent and doc-string-end tokens.
-     *
-     * @param string $str
-     * @return string
+     * Handles (and removes) doc-string-end tokens.
      */
-    protected function handleMagicTokens(string $str) : string {
-        // Replace doc-string-end tokens with nothing or a newline
-        $str = str_replace($this->docStringEndToken . ";\n", ";\n", $str);
-        $str = str_replace($this->docStringEndToken, "\n", $str);
+    protected function handleMagicTokens(string $str): string {
+        if ($this->docStringEndToken !== null) {
+            // Replace doc-string-end tokens with nothing or a newline
+            $str = str_replace(
+                $this->docStringEndToken . ';' . $this->newline,
+                ';' . $this->newline,
+                $str);
+            $str = str_replace($this->docStringEndToken, $this->newline, $str);
+        }
 
         return $str;
     }
@@ -272,12 +340,12 @@ abstract class PrettyPrinterAbstract
     /**
      * 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
+     * @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 {
+    protected function pStmts(array $nodes, bool $indent = true): string {
         if ($indent) {
             $this->indent();
         }
@@ -305,84 +373,96 @@ abstract class PrettyPrinterAbstract
     /**
      * 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 $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 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) : string {
-        list($precedence, $associativity) = $this->precedenceMap[$class];
-
-        return $this->pPrec($leftNode, $precedence, $associativity, -1)
-             . $operatorString
-             . $this->pPrec($rightNode, $precedence, $associativity, 1);
+    protected function pInfixOp(
+        string $class, Node $leftNode, string $operatorString, Node $rightNode,
+        int $precedence, int $lhsPrecedence
+    ): string {
+        list($opPrecedence, $newPrecedenceLHS, $newPrecedenceRHS) = $this->precedenceMap[$class];
+        $prefix = '';
+        $suffix = '';
+        if ($opPrecedence >= $precedence) {
+            $prefix = '(';
+            $suffix = ')';
+            $lhsPrecedence = self::MAX_PRECEDENCE;
+        }
+        return $prefix . $this->p($leftNode, $newPrecedenceLHS, $newPrecedenceLHS)
+            . $operatorString . $this->p($rightNode, $newPrecedenceRHS, $lhsPrecedence) . $suffix;
     }
 
     /**
      * Pretty-print a prefix operation while taking precedence into account.
      *
-     * @param string $class          Node class of operator
+     * @param string $class Node class of operator
      * @param string $operatorString String representation of the operator
-     * @param Node   $node           Node
+     * @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) : string {
-        list($precedence, $associativity) = $this->precedenceMap[$class];
-        return $operatorString . $this->pPrec($node, $precedence, $associativity, 1);
+    protected function pPrefixOp(string $class, string $operatorString, Node $node, int $precedence, int $lhsPrecedence): string {
+        $opPrecedence = $this->precedenceMap[$class][0];
+        $prefix = '';
+        $suffix = '';
+        if ($opPrecedence >= $lhsPrecedence) {
+            $prefix = '(';
+            $suffix = ')';
+            $lhsPrecedence = self::MAX_PRECEDENCE;
+        }
+        $printedArg = $this->p($node, $opPrecedence, $lhsPrecedence);
+        if (($operatorString === '+' && $printedArg[0] === '+') ||
+            ($operatorString === '-' && $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 $class Node class of operator
      * @param string $operatorString String representation of the operator
-     * @param Node   $node           Node
+     * @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) : string {
-        list($precedence, $associativity) = $this->precedenceMap[$class];
-        return $this->pPrec($node, $precedence, $associativity, -1) . $operatorString;
-    }
-
-    /**
-     * Prints an expression node with the least amount of parentheses necessary to preserve the meaning.
-     *
-     * @param Node $node                Node to pretty print
-     * @param int  $parentPrecedence    Precedence of the parent operator
-     * @param int  $parentAssociativity Associativity of parent operator
-     *                                  (-1 is left, 0 is nonassoc, 1 is right)
-     * @param int  $childPosition       Position of the node relative to the operator
-     *                                  (-1 is left, 1 is right)
-     *
-     * @return string The pretty printed node
-     */
-    protected function pPrec(Node $node, int $parentPrecedence, int $parentAssociativity, int $childPosition) : string {
-        $class = \get_class($node);
-        if (isset($this->precedenceMap[$class])) {
-            $childPrecedence = $this->precedenceMap[$class][0];
-            if ($childPrecedence > $parentPrecedence
-                || ($parentPrecedence === $childPrecedence && $parentAssociativity !== $childPosition)
-            ) {
-                return '(' . $this->p($node) . ')';
-            }
+    protected function pPostfixOp(string $class, Node $node, string $operatorString, int $precedence, int $lhsPrecedence): string {
+        $opPrecedence = $this->precedenceMap[$class][0];
+        $prefix = '';
+        $suffix = '';
+        if ($opPrecedence >= $precedence) {
+            $prefix = '(';
+            $suffix = ')';
+            $lhsPrecedence = self::MAX_PRECEDENCE;
         }
-
-        return $this->p($node);
+        if ($opPrecedence < $lhsPrecedence) {
+            $lhsPrecedence = $opPrecedence;
+        }
+        return $prefix . $this->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
+     * @param string $glue Character to implode with
      *
-     * @return string Imploded pretty printed nodes
+     * @return string Imploded pretty printed nodes> $pre
      */
-    protected function pImplode(array $nodes, string $glue = '') : string {
+    protected function pImplode(array $nodes, string $glue = ''): string {
         $pNodes = [];
         foreach ($nodes as $node) {
             if (null === $node) {
@@ -402,7 +482,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return string Comma separated pretty printed nodes
      */
-    protected function pCommaSeparated(array $nodes) : string {
+    protected function pCommaSeparated(array $nodes): string {
         return $this->pImplode($nodes, ', ');
     }
 
@@ -411,12 +491,12 @@ abstract class PrettyPrinterAbstract
      *
      * 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
+     * @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 {
+    protected function pCommaSeparatedMultiline(array $nodes, bool $trailingComma): string {
         $this->indent();
 
         $result = '';
@@ -448,7 +528,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return string Reformatted text of comments
      */
-    protected function pComments(array $comments) : string {
+    protected function pComments(array $comments): string {
         $formattedComments = [];
 
         foreach ($comments as $comment) {
@@ -469,13 +549,11 @@ abstract class PrettyPrinterAbstract
      *  * 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 array  $origTokens Tokens of the original code
-     *
-     * @return string
+     * @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 {
+    public function printFormatPreserving(array $stmts, array $origStmts, array $origTokens): string {
         $this->initializeNodeListDiffer();
         $this->initializeLabelCharMap();
         $this->initializeFixupMap();
@@ -486,25 +564,25 @@ abstract class PrettyPrinterAbstract
         $this->initializeModifierChangeMap();
 
         $this->resetState();
-        $this->origTokens = new TokenStream($origTokens);
+        $this->origTokens = new TokenStream($origTokens, $this->tabWidth);
 
         $this->preprocessNodes($stmts);
 
         $pos = 0;
         $result = $this->pArray($stmts, $origStmts, $pos, 0, 'File', 'stmts', null);
         if (null !== $result) {
-            $result .= $this->origTokens->getTokenCode($pos, count($origTokens), 0);
+            $result .= $this->origTokens->getTokenCode($pos, count($origTokens) - 1, 0);
         } else {
             // Fallback
             // TODO Add <?php properly
-            $result = "<?php\n" . $this->pStmts($stmts, false);
+            $result = "<?php" . $this->newline . $this->pStmts($stmts, false);
         }
 
-        return ltrim($this->handleMagicTokens($result));
+        return $this->handleMagicTokens($result);
     }
 
-    protected function pFallback(Node $node) {
-        return $this->{'p' . $node->getType()}($node);
+    protected function pFallback(Node $node, int $precedence, int $lhsPrecedence): string {
+        return $this->{'p' . $node->getType()}($node, $precedence, $lhsPrecedence);
     }
 
     /**
@@ -513,20 +591,25 @@ abstract class PrettyPrinterAbstract
      * 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, $parentFormatPreserved = false) : string {
+    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->origTokens) {
-            return $this->{'p' . $node->getType()}($node);
+            return $this->{'p' . $node->getType()}($node, $precedence, $lhsPrecedence);
         }
 
-        /** @var Node $origNode */
+        /** @var Node|null $origNode */
         $origNode = $node->getAttribute('origNode');
         if (null === $origNode) {
-            return $this->pFallback($node);
+            return $this->pFallback($node, $precedence, $lhsPrecedence);
         }
 
         $class = \get_class($node);
@@ -539,15 +622,17 @@ abstract class PrettyPrinterAbstract
         $fallbackNode = $node;
         if ($node instanceof Expr\New_ && $node->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 && !$parentFormatPreserved) {
-            return $this->pFallback($fallbackNode);
+            return $this->pFallback($fallbackNode, $precedence, $lhsPrecedence);
         }
 
         $indentAdjustment = $this->indentLevel - $this->origTokens->getIndentationBefore($startPos);
@@ -572,34 +657,27 @@ abstract class PrettyPrinterAbstract
                 if (is_array($subNode) && is_array($origSubNode)) {
                     // Array subnode changed, we might be able to reconstruct it
                     $listResult = $this->pArray(
-                        $subNode, $origSubNode, $pos, $indentAdjustment, $type, $subNodeName,
+                        $subNode, $origSubNode, $pos, $indentAdjustment, $class, $subNodeName,
                         $fixupInfo[$subNodeName] ?? null
                     );
                     if (null === $listResult) {
-                        return $this->pFallback($fallbackNode);
+                        return $this->pFallback($fallbackNode, $precedence, $lhsPrecedence);
                     }
 
                     $result .= $listResult;
                     continue;
                 }
 
-                if (is_int($subNode) && is_int($origSubNode)) {
-                    // Check if this is a modifier change
-                    $key = $type . '->' . $subNodeName;
-                    if (!isset($this->modifierChangeMap[$key])) {
-                        return $this->pFallback($fallbackNode);
-                    }
-
-                    $findToken = $this->modifierChangeMap[$key];
-                    $result .= $this->pModifiers($subNode);
-                    $pos = $this->origTokens->findRight($pos, $findToken);
-                    continue;
+                // Check if this is a modifier change
+                $key = $class . '->' . $subNodeName;
+                if (!isset($this->modifierChangeMap[$key])) {
+                    return $this->pFallback($fallbackNode, $precedence, $lhsPrecedence);
                 }
 
-                // If a non-node, non-array subnode changed, we don't be able to do a partial
-                // reconstructions, as we don't have enough offset information. Pretty print the
-                // whole node instead.
-                return $this->pFallback($fallbackNode);
+                [$printFn, $findToken] = $this->modifierChangeMap[$key];
+                $result .= $this->$printFn($subNode);
+                $pos = $this->origTokens->findRight($pos, $findToken);
+                continue;
             }
 
             $extraLeft = '';
@@ -617,7 +695,7 @@ abstract class PrettyPrinterAbstract
                 // A node has been inserted, check if we have insertion information for it
                 $key = $type . '->' . $subNodeName;
                 if (!isset($this->insertionMap[$key])) {
-                    return $this->pFallback($fallbackNode);
+                    return $this->pFallback($fallbackNode, $precedence, $lhsPrecedence);
                 }
 
                 list($findToken, $beforeToken, $extraLeft, $extraRight) = $this->insertionMap[$key];
@@ -639,7 +717,7 @@ abstract class PrettyPrinterAbstract
                 // A node has been removed, check if we have removal information for it
                 $key = $type . '->' . $subNodeName;
                 if (!isset($this->removalMap[$key])) {
-                    return $this->pFallback($fallbackNode);
+                    return $this->pFallback($fallbackNode, $precedence, $lhsPrecedence);
                 }
 
                 // Adjust positions to account for additional tokens that must be skipped
@@ -658,7 +736,7 @@ abstract class PrettyPrinterAbstract
                 $result .= $extraLeft;
 
                 $origIndentLevel = $this->indentLevel;
-                $this->setIndentLevel($this->origTokens->getIndentationBefore($subStartPos) + $indentAdjustment);
+                $this->setIndentLevel(max($this->origTokens->getIndentationBefore($subStartPos) + $indentAdjustment, 0));
 
                 // 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
@@ -669,7 +747,7 @@ abstract class PrettyPrinterAbstract
                     $fixup = $fixupInfo[$subNodeName];
                     $res = $this->pFixup($fixup, $subNode, $class, $subStartPos, $subEndPos);
                 } else {
-                    $res = $this->p($subNode, true);
+                    $res = $this->p($subNode, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true);
                 }
 
                 $this->safeAppend($result, $res);
@@ -688,23 +766,23 @@ abstract class PrettyPrinterAbstract
     /**
      * Perform a format-preserving pretty print of an array.
      *
-     * @param array       $nodes            New nodes
-     * @param array       $origNodes        Original nodes
-     * @param int         $pos              Current token position (updated by reference)
-     * @param int         $indentAdjustment Adjustment for indentation
-     * @param string      $parentNodeType   Type of the containing node.
-     * @param string      $subNodeName      Name of array subnode.
-     * @param null|int    $fixup            Fixup information for array item nodes
+     * @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 &$pos, int $indentAdjustment,
-        string $parentNodeType, string $subNodeName, $fixup
-    ) {
+        array  $nodes, array $origNodes, int &$pos, int $indentAdjustment,
+        string $parentNodeClass, string $subNodeName, ?int $fixup
+    ): ?string {
         $diff = $this->nodeListDiffer->diffWithReplacements($origNodes, $nodes);
 
-        $mapKey = $parentNodeType . '->' . $subNodeName;
+        $mapKey = $parentNodeClass . '->' . $subNodeName;
         $insertStr = $this->listInsertionMap[$mapKey] ?? null;
         $isStmtList = $subNodeName === 'stmts';
 
@@ -735,9 +813,9 @@ abstract class PrettyPrinterAbstract
         $result = '';
         foreach ($diff as $i => $diffElem) {
             $diffType = $diffElem->type;
-            /** @var Node|null $arrItem */
+            /** @var Node|string|null $arrItem */
             $arrItem = $diffElem->new;
-            /** @var Node|null $origArrItem */
+            /** @var Node|string|null $origArrItem */
             $origArrItem = $diffElem->old;
 
             if ($diffType === DiffElem::TYPE_KEEP || $diffType === DiffElem::TYPE_REPLACE) {
@@ -761,7 +839,7 @@ abstract class PrettyPrinterAbstract
                 \assert($itemStartPos >= 0 && $itemEndPos >= 0 && $itemStartPos >= $pos);
 
                 $origIndentLevel = $this->indentLevel;
-                $lastElemIndentLevel = $this->origTokens->getIndentationBefore($itemStartPos) + $indentAdjustment;
+                $lastElemIndentLevel = max($this->origTokens->getIndentationBefore($itemStartPos) + $indentAdjustment, 0);
                 $this->setIndentLevel($lastElemIndentLevel);
 
                 $comments = $arrItem->getComments();
@@ -776,9 +854,8 @@ abstract class PrettyPrinterAbstract
                 }
 
                 if ($skipRemovedNode) {
-                    if ($isStmtList && ($this->origTokens->haveBracesInRange($pos, $itemStartPos) ||
-                                        $this->origTokens->haveTagInRange($pos, $itemStartPos))) {
-                        // We'd remove the brace of a code block.
+                    if ($isStmtList && $this->origTokens->haveTagInRange($pos, $itemStartPos)) {
+                        // We'd remove an opening/closing PHP tag.
                         // TODO: Preserve formatting.
                         $this->setIndentLevel($origIndentLevel);
                         return null;
@@ -798,7 +875,7 @@ abstract class PrettyPrinterAbstract
                             }
                         }
 
-                        $this->safeAppend($result, $this->p($delayedAddNode, true));
+                        $this->safeAppend($result, $this->p($delayedAddNode, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true));
 
                         if ($insertNewline) {
                             $result .= $insertStr . $this->nl;
@@ -827,10 +904,17 @@ abstract class PrettyPrinterAbstract
                     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 === ', ' &&
-                    ($this->isMultiline($origNodes) || $arrItem->getComments())
+                    ($this->isMultiline($origNodes) || $arrItem->getComments() ||
+                     $parentNodeClass === Expr\Match_::class)
                 ) {
                     $insertStr = ',';
                     $insertNewline = true;
@@ -880,9 +964,8 @@ abstract class PrettyPrinterAbstract
                         $pos, $itemStartPos, $indentAdjustment);
                     $skipRemovedNode = true;
                 } else {
-                    if ($isStmtList && ($this->origTokens->haveBracesInRange($pos, $itemStartPos) ||
-                                        $this->origTokens->haveTagInRange($pos, $itemStartPos))) {
-                        // We'd remove the brace of a code block.
+                    if ($isStmtList && $this->origTokens->haveTagInRange($pos, $itemStartPos)) {
+                        // We'd remove an opening/closing PHP tag.
                         // TODO: Preserve formatting.
                         return null;
                     }
@@ -897,7 +980,7 @@ abstract class PrettyPrinterAbstract
             if (null !== $fixup && $arrItem->getAttribute('origNode') !== $origArrItem) {
                 $res = $this->pFixup($fixup, $arrItem, null, $itemStartPos, $itemEndPos);
             } else {
-                $res = $this->p($arrItem, true);
+                $res = $this->p($arrItem, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true);
             }
             $this->safeAppend($result, $res);
 
@@ -931,7 +1014,7 @@ abstract class PrettyPrinterAbstract
                         $result .= $this->nl;
                     }
                 }
-                $result .= $this->p($delayedAddNode, true);
+                $result .= $this->p($delayedAddNode, self::MAX_PRECEDENCE, self::MAX_PRECEDENCE, true);
                 $first = false;
             }
             $result .= $extraRight === "\n" ? $this->nl : $extraRight;
@@ -947,22 +1030,33 @@ abstract class PrettyPrinterAbstract
      * 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 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
+     * @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, $parentClass, int $subStartPos, int $subEndPos) : string {
+    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->origTokens->haveParens($subStartPos, $subEndPos)) {
+                    $precedence = $this->precedenceMap[$parentClass][1];
+                    return $this->p($subNode, $precedence, $precedence);
+                }
+                break;
             case self::FIXUP_PREC_RIGHT:
                 if (!$this->origTokens->haveParens($subStartPos, $subEndPos)) {
-                    list($precedence, $associativity) = $this->precedenceMap[$parentClass];
-                    return $this->pPrec($subNode, $precedence, $associativity,
-                        $fixup === self::FIXUP_PREC_LEFT ? -1 : 1);
+                    $precedence = $this->precedenceMap[$parentClass][2];
+                    return $this->p($subNode, $precedence, $precedence);
+                }
+                break;
+            case self::FIXUP_PREC_UNARY:
+                if (!$this->origTokens->haveParens($subStartPos, $subEndPos)) {
+                    $precedence = $this->precedenceMap[$parentClass][0];
+                    return $this->p($subNode, $precedence, $precedence);
                 }
                 break;
             case self::FIXUP_CALL_LHS:
@@ -1002,7 +1096,7 @@ abstract class PrettyPrinterAbstract
                 }
                 break;
             case self::FIXUP_ENCAPSED:
-                if (!$subNode instanceof Scalar\EncapsedStringPart
+                if (!$subNode instanceof Node\InterpolatedStringPart
                     && !$this->origTokens->haveBraces($subStartPos, $subEndPos)
                 ) {
                     return '{' . $this->p($subNode) . '}';
@@ -1021,11 +1115,8 @@ abstract class PrettyPrinterAbstract
      *
      * Example: "echo" and "$x" result in "echo$x", but "echo" and "x" result in "echo x".
      * Without safeAppend the result would be "echox", which does not preserve semantics.
-     *
-     * @param string $str
-     * @param string $append
      */
-    protected function safeAppend(string &$str, string $append) {
+    protected function safeAppend(string &$str, string $append): void {
         if ($str === "") {
             $str = $append;
             return;
@@ -1050,7 +1141,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return bool Whether parentheses are required
      */
-    protected function callLhsRequiresParens(Node $node) : bool {
+    protected function callLhsRequiresParens(Node $node): bool {
         return !($node instanceof Node\Name
             || $node instanceof Expr\Variable
             || $node instanceof Expr\ArrayDimFetch
@@ -1068,7 +1159,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return bool Whether parentheses are required
      */
-    protected function dereferenceLhsRequiresParens(Node $node) : bool {
+    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->staticDereferenceLhsRequiresParens($node)
             && !$node instanceof Expr\ConstFetch;
@@ -1126,14 +1217,21 @@ abstract class PrettyPrinterAbstract
      *
      * @return string Printed modifiers
      */
-    protected function pModifiers(int $modifiers) {
-        return ($modifiers & Stmt\Class_::MODIFIER_PUBLIC    ? 'public '    : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_PROTECTED ? 'protected ' : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_PRIVATE   ? 'private '   : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_STATIC    ? 'static '    : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_ABSTRACT  ? 'abstract '  : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_FINAL     ? 'final '     : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_READONLY  ? 'readonly '  : '');
+    protected function pModifiers(int $modifiers): string {
+        return ($modifiers & Modifiers::FINAL ? 'final ' : '')
+             . ($modifiers & Modifiers::ABSTRACT ? 'abstract ' : '')
+             . ($modifiers & Modifiers::PUBLIC ? 'public ' : '')
+             . ($modifiers & Modifiers::PROTECTED ? 'protected ' : '')
+             . ($modifiers & Modifiers::PRIVATE ? 'private ' : '')
+             . ($modifiers & Modifiers::PUBLIC_SET ? 'public(set) ' : '')
+             . ($modifiers & Modifiers::PROTECTED_SET ? 'protected(set) ' : '')
+             . ($modifiers & Modifiers::PRIVATE_SET ? 'private(set) ' : '')
+             . ($modifiers & Modifiers::STATIC ? 'static ' : '')
+             . ($modifiers & Modifiers::READONLY ? 'readonly ' : '');
+    }
+
+    protected function pStatic(bool $static): string {
+        return $static ? 'static ' : '';
     }
 
     /**
@@ -1143,7 +1241,7 @@ abstract class PrettyPrinterAbstract
      *
      * @return bool Whether multiline formatting is used
      */
-    protected function isMultiline(array $nodes) : bool {
+    protected function isMultiline(array $nodes): bool {
         if (\count($nodes) < 2) {
             return false;
         }
@@ -1175,15 +1273,19 @@ abstract class PrettyPrinterAbstract
      *
      * The label char map determines whether a certain character may occur in a label.
      */
-    protected function initializeLabelCharMap() {
-        if ($this->labelCharMap) return;
+    protected function initializeLabelCharMap(): void {
+        if (isset($this->labelCharMap)) {
+            return;
+        }
 
         $this->labelCharMap = [];
         for ($i = 0; $i < 256; $i++) {
-            // Since PHP 7.1 The lower range is 0x80. However, we also want to support code for
-            // older versions.
             $chr = chr($i);
-            $this->labelCharMap[$chr] = $i >= 0x7f || ctype_alnum($chr);
+            $this->labelCharMap[$chr] = $i >= 0x80 || ctype_alnum($chr);
+        }
+
+        if ($this->phpVersion->allowsDelInIdentifiers()) {
+            $this->labelCharMap["\x7f"] = true;
         }
     }
 
@@ -1192,8 +1294,10 @@ abstract class PrettyPrinterAbstract
      *
      * The node list differ is used to determine differences between two array subnodes.
      */
-    protected function initializeNodeListDiffer() {
-        if ($this->nodeListDiffer) return;
+    protected function initializeNodeListDiffer(): void {
+        if (isset($this->nodeListDiffer)) {
+            return;
+        }
 
         $this->nodeListDiffer = new Internal\Differ(function ($a, $b) {
             if ($a instanceof Node && $b instanceof Node) {
@@ -1210,22 +1314,21 @@ abstract class PrettyPrinterAbstract
      * The fixup map is used to determine whether a certain subnode of a certain node may require
      * some kind of "fixup" operation, e.g. the addition of parenthesis or braces.
      */
-    protected function initializeFixupMap() {
-        if ($this->fixupMap) return;
+    protected function initializeFixupMap(): void {
+        if (isset($this->fixupMap)) {
+            return;
+        }
 
         $this->fixupMap = [
-            Expr\PreInc::class => ['var' => self::FIXUP_PREC_RIGHT],
-            Expr\PreDec::class => ['var' => self::FIXUP_PREC_RIGHT],
-            Expr\PostInc::class => ['var' => self::FIXUP_PREC_LEFT],
-            Expr\PostDec::class => ['var' => self::FIXUP_PREC_LEFT],
             Expr\Instanceof_::class => [
-                'expr' => self::FIXUP_PREC_LEFT,
+                'expr' => self::FIXUP_PREC_UNARY,
                 'class' => self::FIXUP_NEW,
             ],
             Expr\Ternary::class => [
                 'cond' => self::FIXUP_PREC_LEFT,
                 'else' => self::FIXUP_PREC_RIGHT,
             ],
+            Expr\Yield_::class => ['value' => self::FIXUP_PREC_UNARY],
 
             Expr\FuncCall::class => ['name' => self::FIXUP_CALL_LHS],
             Expr\StaticCall::class => ['class' => self::FIXUP_STATIC_DEREF_LHS],
@@ -1255,7 +1358,7 @@ abstract class PrettyPrinterAbstract
                 'var' => self::FIXUP_DEREF_LHS,
                 'name' => self::FIXUP_BRACED_NAME,
             ],
-            Scalar\Encapsed::class => [
+            Scalar\InterpolatedString::class => [
                 'parts' => self::FIXUP_ENCAPSED,
             ],
         ];
@@ -1278,27 +1381,19 @@ abstract class PrettyPrinterAbstract
             ];
         }
 
-        $assignOps = [
-            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
-        ];
-        foreach ($assignOps as $assignOp) {
-            $this->fixupMap[$assignOp] = [
-                'var' => self::FIXUP_PREC_LEFT,
-                'expr' => self::FIXUP_PREC_RIGHT,
-            ];
-        }
-
         $prefixOps = [
-            Expr\BitwiseNot::class, Expr\BooleanNot::class, Expr\UnaryPlus::class, Expr\UnaryMinus::class,
+            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->fixupMap[$prefixOp] = ['expr' => self::FIXUP_PREC_RIGHT];
+            $this->fixupMap[$prefixOp] = ['expr' => self::FIXUP_PREC_UNARY];
         }
     }
 
@@ -1308,8 +1403,10 @@ abstract class PrettyPrinterAbstract
      * The removal map is used to determine which additional tokens should be removed when a
      * certain node is replaced by null.
      */
-    protected function initializeRemovalMap() {
-        if ($this->removalMap) return;
+    protected function initializeRemovalMap(): void {
+        if (isset($this->removalMap)) {
+            return;
+        }
 
         $stripBoth = ['left' => \T_WHITESPACE, 'right' => \T_WHITESPACE];
         $stripLeft = ['left' => \T_WHITESPACE];
@@ -1319,7 +1416,7 @@ abstract class PrettyPrinterAbstract
         $stripEquals = ['left' => '='];
         $this->removalMap = [
             'Expr_ArrayDimFetch->dim' => $stripBoth,
-            'Expr_ArrayItem->key' => $stripDoubleArrow,
+            'ArrayItem->key' => $stripDoubleArrow,
             'Expr_ArrowFunction->returnType' => $stripColon,
             'Expr_Closure->returnType' => $stripColon,
             'Expr_Exit->expr' => $stripBoth,
@@ -1342,7 +1439,7 @@ abstract class PrettyPrinterAbstract
             'Stmt_If->else' => $stripLeft,
             'Stmt_Namespace->name' => $stripLeft,
             'Stmt_Property->type' => $stripRight,
-            'Stmt_PropertyProperty->default' => $stripEquals,
+            'PropertyItem->default' => $stripEquals,
             'Stmt_Return->expr' => $stripBoth,
             'Stmt_StaticVar->default' => $stripEquals,
             'Stmt_TraitUseAdaptation_Alias->newName' => $stripLeft,
@@ -1354,16 +1451,18 @@ abstract class PrettyPrinterAbstract
         ];
     }
 
-    protected function initializeInsertionMap() {
-        if ($this->insertionMap) return;
+    protected function initializeInsertionMap(): void {
+        if (isset($this->insertionMap)) {
+            return;
+        }
 
         // TODO: "yield" where both key and value are inserted doesn't work
         // [$find, $beforeToken, $extraLeft, $extraRight]
         $this->insertionMap = [
             'Expr_ArrayDimFetch->dim' => ['[', false, null, null],
-            'Expr_ArrayItem->key' => [null, false, null, ' => '],
-            'Expr_ArrowFunction->returnType' => [')', false, ' : ', null],
-            'Expr_Closure->returnType' => [')', false, ' : ', null],
+            'ArrayItem->key' => [null, false, null, ' => '],
+            'Expr_ArrowFunction->returnType' => [')', false, ': ', null],
+            'Expr_Closure->returnType' => [')', false, ': ', null],
             'Expr_Ternary->if' => ['?', false, ' ', ' '],
             'Expr_Yield->key' => [\T_YIELD, false, null, ' => '],
             'Expr_Yield->value' => [\T_YIELD, false, ' ', null],
@@ -1371,19 +1470,19 @@ abstract class PrettyPrinterAbstract
             'Param->default' => [null, false, ' = ', null],
             'Stmt_Break->num' => [\T_BREAK, false, ' ', null],
             'Stmt_Catch->var' => [null, false, ' ', null],
-            'Stmt_ClassMethod->returnType' => [')', false, ' : ', null],
+            'Stmt_ClassMethod->returnType' => [')', false, ': ', null],
             'Stmt_ClassConst->type' => [\T_CONST, false, ' ', null],
             'Stmt_Class->extends' => [null, false, ' extends ', null],
             'Stmt_Enum->scalarType' => [null, false, ' : ', null],
             'Stmt_EnumCase->expr' => [null, false, ' = ', null],
-            'Expr_PrintableNewAnonClass->extends' => [null, ' extends ', null],
+            'Expr_PrintableNewAnonClass->extends' => [null, false, ' extends ', null],
             'Stmt_Continue->num' => [\T_CONTINUE, false, ' ', null],
             'Stmt_Foreach->keyVar' => [\T_AS, false, null, ' => '],
-            'Stmt_Function->returnType' => [')', false, ' : ', null],
+            'Stmt_Function->returnType' => [')', false, ': ', null],
             'Stmt_If->else' => [null, false, ' ', null],
             'Stmt_Namespace->name' => [\T_NAMESPACE, false, ' ', null],
             'Stmt_Property->type' => [\T_VARIABLE, true, null, ' '],
-            'Stmt_PropertyProperty->default' => [null, false, ' = ', null],
+            'PropertyItem->default' => [null, false, ' = ', null],
             'Stmt_Return->expr' => [\T_RETURN, false, ' ', null],
             'Stmt_StaticVar->default' => [null, false, ' = ', null],
             //'Stmt_TraitUseAdaptation_Alias->newName' => [T_AS, false, ' ', null], // TODO
@@ -1397,132 +1496,146 @@ abstract class PrettyPrinterAbstract
         ];
     }
 
-    protected function initializeListInsertionMap() {
-        if ($this->listInsertionMap) return;
+    protected function initializeListInsertionMap(): void {
+        if (isset($this->listInsertionMap)) {
+            return;
+        }
 
         $this->listInsertionMap = [
             // special
             //'Expr_ShellExec->parts' => '', // TODO These need to be treated more carefully
-            //'Scalar_Encapsed->parts' => '',
-            'Stmt_Catch->types' => '|',
-            'UnionType->types' => '|',
-            'IntersectionType->types' => '&',
-            'Stmt_If->elseifs' => ' ',
-            'Stmt_TryCatch->catches' => ' ',
+            //'Scalar_InterpolatedString->parts' => '',
+            Stmt\Catch_::class . '->types' => '|',
+            UnionType::class . '->types' => '|',
+            IntersectionType::class . '->types' => '&',
+            Stmt\If_::class . '->elseifs' => ' ',
+            Stmt\TryCatch::class . '->catches' => ' ',
 
             // comma-separated lists
-            'Expr_Array->items' => ', ',
-            'Expr_ArrowFunction->params' => ', ',
-            'Expr_Closure->params' => ', ',
-            'Expr_Closure->uses' => ', ',
-            'Expr_FuncCall->args' => ', ',
-            'Expr_Isset->vars' => ', ',
-            'Expr_List->items' => ', ',
-            'Expr_MethodCall->args' => ', ',
-            'Expr_NullsafeMethodCall->args' => ', ',
-            'Expr_New->args' => ', ',
-            'Expr_PrintableNewAnonClass->args' => ', ',
-            'Expr_StaticCall->args' => ', ',
-            'Stmt_ClassConst->consts' => ', ',
-            'Stmt_ClassMethod->params' => ', ',
-            'Stmt_Class->implements' => ', ',
-            'Stmt_Enum->implements' => ', ',
-            'Expr_PrintableNewAnonClass->implements' => ', ',
-            'Stmt_Const->consts' => ', ',
-            'Stmt_Declare->declares' => ', ',
-            'Stmt_Echo->exprs' => ', ',
-            'Stmt_For->init' => ', ',
-            'Stmt_For->cond' => ', ',
-            'Stmt_For->loop' => ', ',
-            'Stmt_Function->params' => ', ',
-            'Stmt_Global->vars' => ', ',
-            'Stmt_GroupUse->uses' => ', ',
-            'Stmt_Interface->extends' => ', ',
-            'Stmt_Match->arms' => ', ',
-            'Stmt_Property->props' => ', ',
-            'Stmt_StaticVar->vars' => ', ',
-            'Stmt_TraitUse->traits' => ', ',
-            'Stmt_TraitUseAdaptation_Precedence->insteadof' => ', ',
-            'Stmt_Unset->vars' => ', ',
-            'Stmt_Use->uses' => ', ',
-            'MatchArm->conds' => ', ',
-            'AttributeGroup->attrs' => ', ',
+            Expr\Array_::class . '->items' => ', ',
+            Expr\ArrowFunction::class . '->params' => ', ',
+            Expr\Closure::class . '->params' => ', ',
+            Expr\Closure::class . '->uses' => ', ',
+            Expr\FuncCall::class . '->args' => ', ',
+            Expr\Isset_::class . '->vars' => ', ',
+            Expr\List_::class . '->items' => ', ',
+            Expr\MethodCall::class . '->args' => ', ',
+            Expr\NullsafeMethodCall::class . '->args' => ', ',
+            Expr\New_::class . '->args' => ', ',
+            PrintableNewAnonClassNode::class . '->args' => ', ',
+            Expr\StaticCall::class . '->args' => ', ',
+            Stmt\ClassConst::class . '->consts' => ', ',
+            Stmt\ClassMethod::class . '->params' => ', ',
+            Stmt\Class_::class . '->implements' => ', ',
+            Stmt\Enum_::class . '->implements' => ', ',
+            PrintableNewAnonClassNode::class . '->implements' => ', ',
+            Stmt\Const_::class . '->consts' => ', ',
+            Stmt\Declare_::class . '->declares' => ', ',
+            Stmt\Echo_::class . '->exprs' => ', ',
+            Stmt\For_::class . '->init' => ', ',
+            Stmt\For_::class . '->cond' => ', ',
+            Stmt\For_::class . '->loop' => ', ',
+            Stmt\Function_::class . '->params' => ', ',
+            Stmt\Global_::class . '->vars' => ', ',
+            Stmt\GroupUse::class . '->uses' => ', ',
+            Stmt\Interface_::class . '->extends' => ', ',
+            Expr\Match_::class . '->arms' => ', ',
+            Stmt\Property::class . '->props' => ', ',
+            Stmt\StaticVar::class . '->vars' => ', ',
+            Stmt\TraitUse::class . '->traits' => ', ',
+            Stmt\TraitUseAdaptation\Precedence::class . '->insteadof' => ', ',
+            Stmt\Unset_::class .  '->vars' => ', ',
+            Stmt\UseUse::class . '->uses' => ', ',
+            MatchArm::class . '->conds' => ', ',
+            AttributeGroup::class . '->attrs' => ', ',
+            PropertyHook::class . '->params' => ', ',
 
             // statement lists
-            'Expr_Closure->stmts' => "\n",
-            'Stmt_Case->stmts' => "\n",
-            'Stmt_Catch->stmts' => "\n",
-            'Stmt_Class->stmts' => "\n",
-            'Stmt_Enum->stmts' => "\n",
-            'Expr_PrintableNewAnonClass->stmts' => "\n",
-            'Stmt_Interface->stmts' => "\n",
-            'Stmt_Trait->stmts' => "\n",
-            'Stmt_ClassMethod->stmts' => "\n",
-            'Stmt_Declare->stmts' => "\n",
-            'Stmt_Do->stmts' => "\n",
-            'Stmt_ElseIf->stmts' => "\n",
-            'Stmt_Else->stmts' => "\n",
-            'Stmt_Finally->stmts' => "\n",
-            'Stmt_Foreach->stmts' => "\n",
-            'Stmt_For->stmts' => "\n",
-            'Stmt_Function->stmts' => "\n",
-            'Stmt_If->stmts' => "\n",
-            'Stmt_Namespace->stmts' => "\n",
-            'Stmt_Class->attrGroups' => "\n",
-            'Stmt_Enum->attrGroups' => "\n",
-            'Stmt_EnumCase->attrGroups' => "\n",
-            'Stmt_Interface->attrGroups' => "\n",
-            'Stmt_Trait->attrGroups' => "\n",
-            'Stmt_Function->attrGroups' => "\n",
-            'Stmt_ClassMethod->attrGroups' => "\n",
-            'Stmt_ClassConst->attrGroups' => "\n",
-            'Stmt_Property->attrGroups' => "\n",
-            'Expr_PrintableNewAnonClass->attrGroups' => ' ',
-            'Expr_Closure->attrGroups' => ' ',
-            'Expr_ArrowFunction->attrGroups' => ' ',
-            'Param->attrGroups' => ' ',
-            'Stmt_Switch->cases' => "\n",
-            'Stmt_TraitUse->adaptations' => "\n",
-            'Stmt_TryCatch->stmts' => "\n",
-            'Stmt_While->stmts' => "\n",
+            Expr\Closure::class . '->stmts' => "\n",
+            Stmt\Case_::class . '->stmts' => "\n",
+            Stmt\Catch_::class . '->stmts' => "\n",
+            Stmt\Class_::class . '->stmts' => "\n",
+            Stmt\Enum_::class . '->stmts' => "\n",
+            PrintableNewAnonClassNode::class . '->stmts' => "\n",
+            Stmt\Interface_::class . '->stmts' => "\n",
+            Stmt\Trait_::class . '->stmts' => "\n",
+            Stmt\ClassMethod::class . '->stmts' => "\n",
+            Stmt\Declare_::class . '->stmts' => "\n",
+            Stmt\Do_::class . '->stmts' => "\n",
+            Stmt\ElseIf_::class . '->stmts' => "\n",
+            Stmt\Else_::class . '->stmts' => "\n",
+            Stmt\Finally_::class . '->stmts' => "\n",
+            Stmt\Foreach_::class . '->stmts' => "\n",
+            Stmt\For_::class . '->stmts' => "\n",
+            Stmt\Function_::class . '->stmts' => "\n",
+            Stmt\If_::class . '->stmts' => "\n",
+            Stmt\Namespace_::class . '->stmts' => "\n",
+            Stmt\Block::class . '->stmts' => "\n",
+
+            // Attribute groups
+            Stmt\Class_::class . '->attrGroups' => "\n",
+            Stmt\Enum_::class . '->attrGroups' => "\n",
+            Stmt\EnumCase::class . '->attrGroups' => "\n",
+            Stmt\Interface_::class . '->attrGroups' => "\n",
+            Stmt\Trait_::class . '->attrGroups' => "\n",
+            Stmt\Function_::class . '->attrGroups' => "\n",
+            Stmt\ClassMethod::class . '->attrGroups' => "\n",
+            Stmt\ClassConst::class . '->attrGroups' => "\n",
+            Stmt\Property::class . '->attrGroups' => "\n",
+            PrintableNewAnonClassNode::class . '->attrGroups' => ' ',
+            Expr\Closure::class . '->attrGroups' => ' ',
+            Expr\ArrowFunction::class . '->attrGroups' => ' ',
+            Param::class . '->attrGroups' => ' ',
+            PropertyHook::class . '->attrGroups' => ' ',
+
+            Stmt\Switch_::class . '->cases' => "\n",
+            Stmt\TraitUse::class . '->adaptations' => "\n",
+            Stmt\TryCatch::class . '->stmts' => "\n",
+            Stmt\While_::class . '->stmts' => "\n",
+            PropertyHook::class . '->body' => "\n",
+            Stmt\Property::class . '->hooks' => "\n",
+            Param::class . '->hooks' => "\n",
 
             // dummy for top-level context
             'File->stmts' => "\n",
         ];
     }
 
-    protected function initializeEmptyListInsertionMap() {
-        if ($this->emptyListInsertionMap) return;
+    protected function initializeEmptyListInsertionMap(): void {
+        if (isset($this->emptyListInsertionMap)) {
+            return;
+        }
 
         // TODO Insertion into empty statement lists.
 
         // [$find, $extraLeft, $extraRight]
         $this->emptyListInsertionMap = [
-            'Expr_ArrowFunction->params' => ['(', '', ''],
-            'Expr_Closure->uses' => [')', ' use(', ')'],
-            'Expr_Closure->params' => ['(', '', ''],
-            'Expr_FuncCall->args' => ['(', '', ''],
-            'Expr_MethodCall->args' => ['(', '', ''],
-            'Expr_NullsafeMethodCall->args' => ['(', '', ''],
-            'Expr_New->args' => ['(', '', ''],
-            'Expr_PrintableNewAnonClass->args' => ['(', '', ''],
-            'Expr_PrintableNewAnonClass->implements' => [null, ' implements ', ''],
-            'Expr_StaticCall->args' => ['(', '', ''],
-            'Stmt_Class->implements' => [null, ' implements ', ''],
-            'Stmt_Enum->implements' => [null, ' implements ', ''],
-            'Stmt_ClassMethod->params' => ['(', '', ''],
-            'Stmt_Interface->extends' => [null, ' extends ', ''],
-            'Stmt_Function->params' => ['(', '', ''],
-            'Stmt_Interface->attrGroups' => [null, '', "\n"],
-            'Stmt_Class->attrGroups' => [null, '', "\n"],
-            'Stmt_ClassConst->attrGroups' => [null, '', "\n"],
-            'Stmt_ClassMethod->attrGroups' => [null, '', "\n"],
-            'Stmt_Function->attrGroups' => [null, '', "\n"],
-            'Stmt_Property->attrGroups' => [null, '', "\n"],
-            'Stmt_Trait->attrGroups' => [null, '', "\n"],
-            'Expr_ArrowFunction->attrGroups' => [null, '', ' '],
-            'Expr_Closure->attrGroups' => [null, '', ' '],
-            'Expr_PrintableNewAnonClass->attrGroups' => [\T_NEW, ' ', ''],
+            Expr\ArrowFunction::class . '->params' => ['(', '', ''],
+            Expr\Closure::class . '->uses' => [')', ' use (', ')'],
+            Expr\Closure::class . '->params' => ['(', '', ''],
+            Expr\FuncCall::class . '->args' => ['(', '', ''],
+            Expr\MethodCall::class . '->args' => ['(', '', ''],
+            Expr\NullsafeMethodCall::class . '->args' => ['(', '', ''],
+            Expr\New_::class . '->args' => ['(', '', ''],
+            PrintableNewAnonClassNode::class . '->args' => ['(', '', ''],
+            PrintableNewAnonClassNode::class . '->implements' => [null, ' implements ', ''],
+            Expr\StaticCall::class . '->args' => ['(', '', ''],
+            Stmt\Class_::class . '->implements' => [null, ' implements ', ''],
+            Stmt\Enum_::class . '->implements' => [null, ' implements ', ''],
+            Stmt\ClassMethod::class . '->params' => ['(', '', ''],
+            Stmt\Interface_::class . '->extends' => [null, ' extends ', ''],
+            Stmt\Function_::class . '->params' => ['(', '', ''],
+            Stmt\Interface_::class . '->attrGroups' => [null, '', "\n"],
+            Stmt\Class_::class . '->attrGroups' => [null, '', "\n"],
+            Stmt\ClassConst::class . '->attrGroups' => [null, '', "\n"],
+            Stmt\ClassMethod::class . '->attrGroups' => [null, '', "\n"],
+            Stmt\Function_::class . '->attrGroups' => [null, '', "\n"],
+            Stmt\Property::class . '->attrGroups' => [null, '', "\n"],
+            Stmt\Trait_::class . '->attrGroups' => [null, '', "\n"],
+            Expr\ArrowFunction::class . '->attrGroups' => [null, '', ' '],
+            Expr\Closure::class . '->attrGroups' => [null, '', ' '],
+            Stmt\Const_::class . '->attrGroups' => [null, '', "\n"],
+            PrintableNewAnonClassNode::class . '->attrGroups' => [\T_NEW, ' ', ''],
 
             /* These cannot be empty to start with:
              * Expr_Isset->vars
@@ -1554,23 +1667,28 @@ abstract class PrettyPrinterAbstract
         ];
     }
 
-    protected function initializeModifierChangeMap() {
-        if ($this->modifierChangeMap) return;
+    protected function initializeModifierChangeMap(): void {
+        if (isset($this->modifierChangeMap)) {
+            return;
+        }
 
         $this->modifierChangeMap = [
-            'Stmt_ClassConst->flags' => \T_CONST,
-            'Stmt_ClassMethod->flags' => \T_FUNCTION,
-            'Stmt_Class->flags' => \T_CLASS,
-            'Stmt_Property->flags' => \T_VARIABLE,
-            'Expr_PrintableNewAnonClass->flags' => \T_CLASS,
-            'Param->flags' => \T_VARIABLE,
-            //'Stmt_TraitUseAdaptation_Alias->newModifier' => 0, // TODO
+            Stmt\ClassConst::class . '->flags' => ['pModifiers', \T_CONST],
+            Stmt\ClassMethod::class . '->flags' => ['pModifiers', \T_FUNCTION],
+            Stmt\Class_::class . '->flags' => ['pModifiers', \T_CLASS],
+            Stmt\Property::class . '->flags' => ['pModifiers', \T_VARIABLE],
+            PrintableNewAnonClassNode::class . '->flags' => ['pModifiers', \T_CLASS],
+            Param::class . '->flags' => ['pModifiers', \T_VARIABLE],
+            PropertyHook::class . '->flags' => ['pModifiers', \T_STRING],
+            Expr\Closure::class . '->static' => ['pStatic', \T_FUNCTION],
+            Expr\ArrowFunction::class . '->static' => ['pStatic', \T_FN],
+            //Stmt\TraitUseAdaptation\Alias::class . '->newModifier' => 0, // TODO
         ];
 
         // List of integer subnodes that are not modifiers:
         // Expr_Include->type
         // Stmt_GroupUse->type
         // Stmt_Use->type
-        // Stmt_UseUse->type
+        // UseItem->type
     }
 }