@appthreat/atom 1.8.1 → 1.8.2

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

@@ -2,40 +2,51 @@
 
 namespace PhpParser;
 
-class NodeTraverser implements NodeTraverserInterface {
+class NodeTraverser implements NodeTraverserInterface
+{
     /**
-     * @deprecated Use NodeVisitor::DONT_TRAVERSE_CHILDREN instead.
+     * If NodeVisitor::enterNode() returns DONT_TRAVERSE_CHILDREN, child nodes
+     * of the current node will not be traversed for any visitors.
+     *
+     * For subsequent visitors enterNode() will still be called on the current
+     * node and leaveNode() will also be invoked for the current node.
      */
-    public const DONT_TRAVERSE_CHILDREN = NodeVisitor::DONT_TRAVERSE_CHILDREN;
+    const DONT_TRAVERSE_CHILDREN = 1;
 
     /**
-     * @deprecated Use NodeVisitor::STOP_TRAVERSAL instead.
+     * If NodeVisitor::enterNode() or NodeVisitor::leaveNode() returns
+     * STOP_TRAVERSAL, traversal is aborted.
+     *
+     * The afterTraverse() method will still be invoked.
      */
-    public const STOP_TRAVERSAL = NodeVisitor::STOP_TRAVERSAL;
+    const STOP_TRAVERSAL = 2;
 
     /**
-     * @deprecated Use NodeVisitor::REMOVE_NODE instead.
+     * If NodeVisitor::leaveNode() returns REMOVE_NODE for a node that occurs
+     * in an array, it will be removed from the array.
+     *
+     * For subsequent visitors leaveNode() will still be invoked for the
+     * removed node.
      */
-    public const REMOVE_NODE = NodeVisitor::REMOVE_NODE;
+    const REMOVE_NODE = 3;
 
     /**
-     * @deprecated Use NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN instead.
+     * If NodeVisitor::enterNode() returns DONT_TRAVERSE_CURRENT_AND_CHILDREN, child nodes
+     * of the current node will not be traversed for any visitors.
+     *
+     * For subsequent visitors enterNode() will not be called as well.
+     * leaveNode() will be invoked for visitors that has enterNode() method invoked.
      */
-    public const DONT_TRAVERSE_CURRENT_AND_CHILDREN = NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN;
+    const DONT_TRAVERSE_CURRENT_AND_CHILDREN = 4;
 
-    /** @var list<NodeVisitor> Visitors */
-    protected array $visitors = [];
+    /** @var NodeVisitor[] Visitors */
+    protected $visitors = [];
 
     /** @var bool Whether traversal should be stopped */
-    protected bool $stopTraversal;
+    protected $stopTraversal;
 
-    /**
-     * Create a traverser with the given visitors.
-     *
-     * @param NodeVisitor ...$visitors Node visitors
-     */
-    public function __construct(NodeVisitor ...$visitors) {
-        $this->visitors = $visitors;
+    public function __construct() {
+        // for BC
     }
 
     /**
@@ -43,17 +54,21 @@ class NodeTraverser implements NodeTraverserInterface {
      *
      * @param NodeVisitor $visitor Visitor to add
      */
-    public function addVisitor(NodeVisitor $visitor): void {
+    public function addVisitor(NodeVisitor $visitor) {
         $this->visitors[] = $visitor;
     }
 
     /**
      * Removes an added visitor.
+     *
+     * @param NodeVisitor $visitor
      */
-    public function removeVisitor(NodeVisitor $visitor): void {
-        $index = array_search($visitor, $this->visitors);
-        if ($index !== false) {
-            array_splice($this->visitors, $index, 1, []);
+    public function removeVisitor(NodeVisitor $visitor) {
+        foreach ($this->visitors as $index => $storedVisitor) {
+            if ($storedVisitor === $visitor) {
+                unset($this->visitors[$index]);
+                break;
+            }
         }
     }
 
@@ -64,7 +79,7 @@ class NodeTraverser implements NodeTraverserInterface {
      *
      * @return Node[] Traversed array of nodes
      */
-    public function traverse(array $nodes): array {
+    public function traverse(array $nodes) : array {
         $this->stopTraversal = false;
 
         foreach ($this->visitors as $visitor) {
@@ -75,8 +90,7 @@ class NodeTraverser implements NodeTraverserInterface {
 
         $nodes = $this->traverseArray($nodes);
 
-        for ($i = \count($this->visitors) - 1; $i >= 0; --$i) {
-            $visitor = $this->visitors[$i];
+        foreach ($this->visitors as $visitor) {
             if (null !== $return = $visitor->afterTraverse($nodes)) {
                 $nodes = $return;
             }
@@ -89,37 +103,37 @@ class NodeTraverser implements NodeTraverserInterface {
      * Recursively traverse a node.
      *
      * @param Node $node Node to traverse.
+     *
+     * @return Node Result of traversal (may be original node or new one)
      */
-    protected function traverseNode(Node $node): void {
+    protected function traverseNode(Node $node) : Node {
         foreach ($node->getSubNodeNames() as $name) {
-            $subNode = $node->$name;
+            $subNode =& $node->$name;
 
             if (\is_array($subNode)) {
-                $node->$name = $this->traverseArray($subNode);
+                $subNode = $this->traverseArray($subNode);
                 if ($this->stopTraversal) {
                     break;
                 }
             } elseif ($subNode instanceof Node) {
                 $traverseChildren = true;
-                $visitorIndex = -1;
+                $breakVisitorIndex = null;
 
                 foreach ($this->visitors as $visitorIndex => $visitor) {
                     $return = $visitor->enterNode($subNode);
                     if (null !== $return) {
                         if ($return instanceof Node) {
                             $this->ensureReplacementReasonable($subNode, $return);
-                            $subNode = $node->$name = $return;
-                        } elseif (NodeVisitor::DONT_TRAVERSE_CHILDREN === $return) {
+                            $subNode = $return;
+                        } elseif (self::DONT_TRAVERSE_CHILDREN === $return) {
                             $traverseChildren = false;
-                        } elseif (NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
+                        } elseif (self::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
                             $traverseChildren = false;
+                            $breakVisitorIndex = $visitorIndex;
                             break;
-                        } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+                        } elseif (self::STOP_TRAVERSAL === $return) {
                             $this->stopTraversal = true;
                             break 2;
-                        } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
-                            $node->$name = null;
-                            continue 2;
                         } else {
                             throw new \LogicException(
                                 'enterNode() returned invalid value of type ' . gettype($return)
@@ -129,26 +143,22 @@ class NodeTraverser implements NodeTraverserInterface {
                 }
 
                 if ($traverseChildren) {
-                    $this->traverseNode($subNode);
+                    $subNode = $this->traverseNode($subNode);
                     if ($this->stopTraversal) {
                         break;
                     }
                 }
 
-                for (; $visitorIndex >= 0; --$visitorIndex) {
-                    $visitor = $this->visitors[$visitorIndex];
+                foreach ($this->visitors as $visitorIndex => $visitor) {
                     $return = $visitor->leaveNode($subNode);
 
                     if (null !== $return) {
                         if ($return instanceof Node) {
                             $this->ensureReplacementReasonable($subNode, $return);
-                            $subNode = $node->$name = $return;
-                        } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+                            $subNode = $return;
+                        } elseif (self::STOP_TRAVERSAL === $return) {
                             $this->stopTraversal = true;
                             break 2;
-                        } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
-                            $node->$name = null;
-                            break;
                         } elseif (\is_array($return)) {
                             throw new \LogicException(
                                 'leaveNode() may only return an array ' .
@@ -160,9 +170,15 @@ class NodeTraverser implements NodeTraverserInterface {
                             );
                         }
                     }
+
+                    if ($breakVisitorIndex === $visitorIndex) {
+                        break;
+                    }
                 }
             }
         }
+
+        return $node;
     }
 
     /**
@@ -172,37 +188,29 @@ class NodeTraverser implements NodeTraverserInterface {
      *
      * @return array Result of traversal (may be original array or changed one)
      */
-    protected function traverseArray(array $nodes): array {
+    protected function traverseArray(array $nodes) : array {
         $doNodes = [];
 
-        foreach ($nodes as $i => $node) {
+        foreach ($nodes as $i => &$node) {
             if ($node instanceof Node) {
                 $traverseChildren = true;
-                $visitorIndex = -1;
+                $breakVisitorIndex = null;
 
                 foreach ($this->visitors as $visitorIndex => $visitor) {
                     $return = $visitor->enterNode($node);
                     if (null !== $return) {
                         if ($return instanceof Node) {
                             $this->ensureReplacementReasonable($node, $return);
-                            $nodes[$i] = $node = $return;
-                        } elseif (\is_array($return)) {
-                            $doNodes[] = [$i, $return];
-                            continue 2;
-                        } elseif (NodeVisitor::REMOVE_NODE === $return) {
-                            $doNodes[] = [$i, []];
-                            continue 2;
-                        } elseif (NodeVisitor::DONT_TRAVERSE_CHILDREN === $return) {
+                            $node = $return;
+                        } elseif (self::DONT_TRAVERSE_CHILDREN === $return) {
                             $traverseChildren = false;
-                        } elseif (NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
+                        } elseif (self::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
                             $traverseChildren = false;
+                            $breakVisitorIndex = $visitorIndex;
                             break;
-                        } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+                        } elseif (self::STOP_TRAVERSAL === $return) {
                             $this->stopTraversal = true;
                             break 2;
-                        } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
-                            throw new \LogicException(
-                                'REPLACE_WITH_NULL can not be used if the parent structure is an array');
                         } else {
                             throw new \LogicException(
                                 'enterNode() returned invalid value of type ' . gettype($return)
@@ -212,38 +220,43 @@ class NodeTraverser implements NodeTraverserInterface {
                 }
 
                 if ($traverseChildren) {
-                    $this->traverseNode($node);
+                    $node = $this->traverseNode($node);
                     if ($this->stopTraversal) {
                         break;
                     }
                 }
 
-                for (; $visitorIndex >= 0; --$visitorIndex) {
-                    $visitor = $this->visitors[$visitorIndex];
+                foreach ($this->visitors as $visitorIndex => $visitor) {
                     $return = $visitor->leaveNode($node);
 
                     if (null !== $return) {
                         if ($return instanceof Node) {
                             $this->ensureReplacementReasonable($node, $return);
-                            $nodes[$i] = $node = $return;
+                            $node = $return;
                         } elseif (\is_array($return)) {
                             $doNodes[] = [$i, $return];
                             break;
-                        } elseif (NodeVisitor::REMOVE_NODE === $return) {
+                        } elseif (self::REMOVE_NODE === $return) {
                             $doNodes[] = [$i, []];
                             break;
-                        } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+                        } elseif (self::STOP_TRAVERSAL === $return) {
                             $this->stopTraversal = true;
                             break 2;
-                        } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
+                        } elseif (false === $return) {
                             throw new \LogicException(
-                                'REPLACE_WITH_NULL can not be used if the parent structure is an array');
+                                'bool(false) return from leaveNode() no longer supported. ' .
+                                'Return NodeTraverser::REMOVE_NODE instead'
+                            );
                         } else {
                             throw new \LogicException(
                                 'leaveNode() returned invalid value of type ' . gettype($return)
                             );
                         }
                     }
+
+                    if ($breakVisitorIndex === $visitorIndex) {
+                        break;
+                    }
                 }
             } elseif (\is_array($node)) {
                 throw new \LogicException('Invalid node structure: Contains nested arrays');
@@ -259,7 +272,7 @@ class NodeTraverser implements NodeTraverserInterface {
         return $nodes;
     }
 
-    private function ensureReplacementReasonable(Node $old, Node $new): void {
+    private function ensureReplacementReasonable($old, $new) {
         if ($old instanceof Node\Stmt && $new instanceof Node\Expr) {
             throw new \LogicException(
                 "Trying to replace statement ({$old->getType()}) " .

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

@@ -2,18 +2,21 @@
 
 namespace PhpParser;
 
-interface NodeTraverserInterface {
+interface NodeTraverserInterface
+{
     /**
      * Adds a visitor.
      *
      * @param NodeVisitor $visitor Visitor to add
      */
-    public function addVisitor(NodeVisitor $visitor): void;
+    public function addVisitor(NodeVisitor $visitor);
 
     /**
      * Removes an added visitor.
+     *
+     * @param NodeVisitor $visitor
      */
-    public function removeVisitor(NodeVisitor $visitor): void;
+    public function removeVisitor(NodeVisitor $visitor);
 
     /**
      * Traverses an array of nodes using the registered visitors.
@@ -22,5 +25,5 @@ interface NodeTraverserInterface {
      *
      * @return Node[] Traversed array of nodes
      */
-    public function traverse(array $nodes): array;
+    public function traverse(array $nodes) : array;
 }

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php

@@ -10,7 +10,8 @@ use PhpParser\NodeVisitorAbstract;
  *
  * This visitor is required to perform format-preserving pretty prints.
  */
-class CloningVisitor extends NodeVisitorAbstract {
+class CloningVisitor extends NodeVisitorAbstract
+{
     public function enterNode(Node $origNode) {
         $node = clone $origNode;
         $node->setAttribute('origNode', $origNode);

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php

@@ -9,11 +9,12 @@ use PhpParser\NodeVisitorAbstract;
  * This visitor can be used to find and collect all nodes satisfying some criterion determined by
  * a filter callback.
  */
-class FindingVisitor extends NodeVisitorAbstract {
+class FindingVisitor extends NodeVisitorAbstract
+{
     /** @var callable Filter callback */
     protected $filterCallback;
     /** @var Node[] Found nodes */
-    protected array $foundNodes;
+    protected $foundNodes;
 
     public function __construct(callable $filterCallback) {
         $this->filterCallback = $filterCallback;
@@ -26,11 +27,11 @@ class FindingVisitor extends NodeVisitorAbstract {
      *
      * @return Node[] Found nodes
      */
-    public function getFoundNodes(): array {
+    public function getFoundNodes() : array {
         return $this->foundNodes;
     }
 
-    public function beforeTraverse(array $nodes): ?array {
+    public function beforeTraverse(array $nodes) {
         $this->foundNodes = [];
 
         return null;

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php

@@ -3,18 +3,19 @@
 namespace PhpParser\NodeVisitor;
 
 use PhpParser\Node;
-use PhpParser\NodeVisitor;
+use PhpParser\NodeTraverser;
 use PhpParser\NodeVisitorAbstract;
 
 /**
  * This visitor can be used to find the first node satisfying some criterion determined by
  * a filter callback.
  */
-class FirstFindingVisitor extends NodeVisitorAbstract {
+class FirstFindingVisitor extends NodeVisitorAbstract
+{
     /** @var callable Filter callback */
     protected $filterCallback;
     /** @var null|Node Found node */
-    protected ?Node $foundNode;
+    protected $foundNode;
 
     public function __construct(callable $filterCallback) {
         $this->filterCallback = $filterCallback;
@@ -27,11 +28,11 @@ class FirstFindingVisitor extends NodeVisitorAbstract {
      *
      * @return null|Node Found node (or null if not found)
      */
-    public function getFoundNode(): ?Node {
+    public function getFoundNode() {
         return $this->foundNode;
     }
 
-    public function beforeTraverse(array $nodes): ?array {
+    public function beforeTraverse(array $nodes) {
         $this->foundNode = null;
 
         return null;
@@ -41,7 +42,7 @@ class FirstFindingVisitor extends NodeVisitorAbstract {
         $filterCallback = $this->filterCallback;
         if ($filterCallback($node)) {
             $this->foundNode = $node;
-            return NodeVisitor::STOP_TRAVERSAL;
+            return NodeTraverser::STOP_TRAVERSAL;
         }
 
         return null;

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php

@@ -11,15 +11,16 @@ use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt;
 use PhpParser\NodeVisitorAbstract;
 
-class NameResolver extends NodeVisitorAbstract {
+class NameResolver extends NodeVisitorAbstract
+{
     /** @var NameContext Naming context */
-    protected NameContext $nameContext;
+    protected $nameContext;
 
     /** @var bool Whether to preserve original names */
-    protected bool $preserveOriginalNames;
+    protected $preserveOriginalNames;
 
     /** @var bool Whether to replace resolved nodes in place, or to add resolvedNode attributes */
-    protected bool $replaceNodes;
+    protected $replaceNodes;
 
     /**
      * Constructs a name resolution visitor.
@@ -32,22 +33,24 @@ class NameResolver extends NodeVisitorAbstract {
      *    namespacedName attribute, as usual.)
      *
      * @param ErrorHandler|null $errorHandler Error handler
-     * @param array{preserveOriginalNames?: bool, replaceNodes?: bool} $options Options
+     * @param array $options Options
      */
-    public function __construct(?ErrorHandler $errorHandler = null, array $options = []) {
-        $this->nameContext = new NameContext($errorHandler ?? new ErrorHandler\Throwing());
+    public function __construct(ErrorHandler $errorHandler = null, array $options = []) {
+        $this->nameContext = new NameContext($errorHandler ?? new ErrorHandler\Throwing);
         $this->preserveOriginalNames = $options['preserveOriginalNames'] ?? false;
         $this->replaceNodes = $options['replaceNodes'] ?? true;
     }
 
     /**
      * Get name resolution context.
+     *
+     * @return NameContext
      */
-    public function getNameContext(): NameContext {
+    public function getNameContext() : NameContext {
         return $this->nameContext;
     }
 
-    public function beforeTraverse(array $nodes): ?array {
+    public function beforeTraverse(array $nodes) {
         $this->nameContext->startNamespace();
         return null;
     }
@@ -75,8 +78,6 @@ class NameResolver extends NodeVisitorAbstract {
             $this->resolveAttrGroups($node);
             if (null !== $node->name) {
                 $this->addNamespacedName($node);
-            } else {
-                $node->namespacedName = null;
             }
         } elseif ($node instanceof Stmt\Interface_) {
             foreach ($node->extends as &$interface) {
@@ -85,13 +86,15 @@ class NameResolver extends NodeVisitorAbstract {
 
             $this->resolveAttrGroups($node);
             $this->addNamespacedName($node);
-        } elseif ($node instanceof Stmt\Enum_) {
+         } elseif ($node instanceof Stmt\Enum_) {
             foreach ($node->implements as &$interface) {
                 $interface = $this->resolveClassName($interface);
             }
 
             $this->resolveAttrGroups($node);
-            $this->addNamespacedName($node);
+            if (null !== $node->name) {
+                $this->addNamespacedName($node);
+            }
         } elseif ($node instanceof Stmt\Trait_) {
             $this->resolveAttrGroups($node);
             $this->addNamespacedName($node);
@@ -114,12 +117,12 @@ class NameResolver extends NodeVisitorAbstract {
             foreach ($node->consts as $const) {
                 $this->addNamespacedName($const);
             }
-        } elseif ($node instanceof Stmt\ClassConst) {
+        } else if ($node instanceof Stmt\ClassConst) {
             if (null !== $node->type) {
                 $node->type = $this->resolveType($node->type);
             }
             $this->resolveAttrGroups($node);
-        } elseif ($node instanceof Stmt\EnumCase) {
+        } else if ($node instanceof Stmt\EnumCase) {
             $this->resolveAttrGroups($node);
         } elseif ($node instanceof Expr\StaticCall
                   || $node instanceof Expr\StaticPropertyFetch
@@ -161,8 +164,7 @@ class NameResolver extends NodeVisitorAbstract {
         return null;
     }
 
-    /** @param Stmt\Use_::TYPE_* $type */
-    private function addAlias(Node\UseItem $use, int $type, ?Name $prefix = null): void {
+    private function addAlias(Stmt\UseUse $use, int $type, Name $prefix = null) {
         // Add prefix for group uses
         $name = $prefix ? Name::concat($prefix, $use->name) : $use->name;
         // Type is determined either by individual element or whole use declaration
@@ -173,8 +175,8 @@ class NameResolver extends NodeVisitorAbstract {
         );
     }
 
-    /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure|Expr\ArrowFunction $node */
-    private function resolveSignature($node): void {
+    /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure $node */
+    private function resolveSignature($node) {
         foreach ($node->params as $param) {
             $param->type = $this->resolveType($param->type);
             $this->resolveAttrGroups($param);
@@ -182,12 +184,7 @@ class NameResolver extends NodeVisitorAbstract {
         $node->returnType = $this->resolveType($node->returnType);
     }
 
-    /**
-     * @template T of Node\Identifier|Name|Node\ComplexType|null
-     * @param T $node
-     * @return T
-     */
-    private function resolveType(?Node $node): ?Node {
+    private function resolveType($node) {
         if ($node instanceof Name) {
             return $this->resolveClassName($node);
         }
@@ -208,11 +205,11 @@ class NameResolver extends NodeVisitorAbstract {
      * Resolve name, according to name resolver options.
      *
      * @param Name $name Function or constant name to resolve
-     * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+     * @param int  $type One of Stmt\Use_::TYPE_*
      *
      * @return Name Resolved name, or original name with attribute
      */
-    protected function resolveName(Name $name, int $type): Name {
+    protected function resolveName(Name $name, int $type) : Name {
         if (!$this->replaceNodes) {
             $resolvedName = $this->nameContext->getResolvedName($name, $type);
             if (null !== $resolvedName) {
@@ -243,16 +240,17 @@ class NameResolver extends NodeVisitorAbstract {
         return $name;
     }
 
-    protected function resolveClassName(Name $name): Name {
+    protected function resolveClassName(Name $name) {
         return $this->resolveName($name, Stmt\Use_::TYPE_NORMAL);
     }
 
-    protected function addNamespacedName(Node $node): void {
+    protected function addNamespacedName(Node $node) {
         $node->namespacedName = Name::concat(
             $this->nameContext->getNamespace(), (string) $node->name);
     }
 
-    protected function resolveAttrGroups(Node $node): void {
+    protected function resolveAttrGroups(Node $node)
+    {
         foreach ($node->attrGroups as $attrGroup) {
             foreach ($attrGroup->attrs as $attr) {
                 $attr->name = $this->resolveClassName($attr->name);

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php

@@ -14,11 +14,12 @@ use PhpParser\NodeVisitorAbstract;
  * node can be accessed through <code>$node->getAttribute('previous')</code>,
  * and the next node can be accessed through <code>$node->getAttribute('next')</code>.
  */
-final class NodeConnectingVisitor extends NodeVisitorAbstract {
+final class NodeConnectingVisitor extends NodeVisitorAbstract
+{
     /**
      * @var Node[]
      */
-    private array $stack = [];
+    private $stack = [];
 
     /**
      * @var ?Node

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/ParentConnectingVisitor.php

@@ -2,11 +2,10 @@
 
 namespace PhpParser\NodeVisitor;
 
-use PhpParser\Node;
-use PhpParser\NodeVisitorAbstract;
-
 use function array_pop;
 use function count;
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
 
 /**
  * Visitor that connects a child node to its parent node.
@@ -14,17 +13,20 @@ use function count;
  * On the child node, the parent node can be accessed through
  * <code>$node->getAttribute('parent')</code>.
  */
-final class ParentConnectingVisitor extends NodeVisitorAbstract {
+final class ParentConnectingVisitor extends NodeVisitorAbstract
+{
     /**
      * @var Node[]
      */
-    private array $stack = [];
+    private $stack = [];
 
-    public function beforeTraverse(array $nodes) {
+    public function beforeTraverse(array $nodes)
+    {
         $this->stack = [];
     }
 
-    public function enterNode(Node $node) {
+    public function enterNode(Node $node)
+    {
         if (!empty($this->stack)) {
             $node->setAttribute('parent', $this->stack[count($this->stack) - 1]);
         }
@@ -32,7 +34,8 @@ final class ParentConnectingVisitor extends NodeVisitorAbstract {
         $this->stack[] = $node;
     }
 
-    public function leaveNode(Node $node) {
+    public function leaveNode(Node $node)
+    {
         array_pop($this->stack);
     }
 }