@flarum/cli 2.0.0-beta.8 → 3.0.0

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeFinder.php

@@ -5,25 +5,27 @@ namespace PhpParser;
 use PhpParser\NodeVisitor\FindingVisitor;
 use PhpParser\NodeVisitor\FirstFindingVisitor;
 
-class NodeFinder
-{
+class NodeFinder {
     /**
      * Find all nodes satisfying a filter callback.
      *
-     * @param Node|Node[] $nodes  Single node or array of nodes to search in
-     * @param callable    $filter Filter callback: function(Node $node) : bool
+     * @param Node|Node[] $nodes Single node or array of nodes to search in
+     * @param callable $filter Filter callback: function(Node $node) : bool
      *
      * @return Node[] Found nodes satisfying the filter callback
      */
-    public function find($nodes, callable $filter) : array {
+    public function find($nodes, callable $filter): array {
+        if ($nodes === []) {
+            return [];
+        }
+
         if (!is_array($nodes)) {
             $nodes = [$nodes];
         }
 
         $visitor = new FindingVisitor($filter);
 
-        $traverser = new NodeTraverser;
-        $traverser->addVisitor($visitor);
+        $traverser = new NodeTraverser($visitor);
         $traverser->traverse($nodes);
 
         return $visitor->getFoundNodes();
@@ -31,13 +33,15 @@ class NodeFinder
 
     /**
      * Find all nodes that are instances of a certain class.
+
+     * @template TNode as Node
      *
      * @param Node|Node[] $nodes Single node or array of nodes to search in
-     * @param string      $class Class name
+     * @param class-string<TNode> $class Class name
      *
-     * @return Node[] Found nodes (all instances of $class)
+     * @return TNode[] Found nodes (all instances of $class)
      */
-    public function findInstanceOf($nodes, string $class) : array {
+    public function findInstanceOf($nodes, string $class): array {
         return $this->find($nodes, function ($node) use ($class) {
             return $node instanceof $class;
         });
@@ -46,20 +50,23 @@ class NodeFinder
     /**
      * Find first node satisfying a filter callback.
      *
-     * @param Node|Node[] $nodes  Single node or array of nodes to search in
-     * @param callable    $filter Filter callback: function(Node $node) : bool
+     * @param Node|Node[] $nodes Single node or array of nodes to search in
+     * @param callable $filter Filter callback: function(Node $node) : bool
      *
      * @return null|Node Found node (or null if none found)
      */
-    public function findFirst($nodes, callable $filter) {
+    public function findFirst($nodes, callable $filter): ?Node {
+        if ($nodes === []) {
+            return null;
+        }
+
         if (!is_array($nodes)) {
             $nodes = [$nodes];
         }
 
         $visitor = new FirstFindingVisitor($filter);
 
-        $traverser = new NodeTraverser;
-        $traverser->addVisitor($visitor);
+        $traverser = new NodeTraverser($visitor);
         $traverser->traverse($nodes);
 
         return $visitor->getFoundNode();
@@ -68,12 +75,14 @@ class NodeFinder
     /**
      * Find first node that is an instance of a certain class.
      *
-     * @param Node|Node[] $nodes  Single node or array of nodes to search in
-     * @param string      $class Class name
+     * @template TNode as Node
+     *
+     * @param Node|Node[] $nodes Single node or array of nodes to search in
+     * @param class-string<TNode> $class Class name
      *
-     * @return null|Node Found node, which is an instance of $class (or null if none found)
+     * @return null|TNode Found node, which is an instance of $class (or null if none found)
      */
-    public function findFirstInstanceOf($nodes, string $class) {
+    public function findFirstInstanceOf($nodes, string $class): ?Node {
         return $this->findFirst($nodes, function ($node) use ($class) {
             return $node instanceof $class;
         });

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeTraverser.php

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

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeTraverserInterface.php

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

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php

@@ -10,8 +10,7 @@ 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/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CommentAnnotatingVisitor.php

@@ -0,0 +1,82 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\NodeVisitor;
+
+use PhpParser\Comment;
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+use PhpParser\Token;
+
+class CommentAnnotatingVisitor extends NodeVisitorAbstract {
+    /** @var int Last seen token start position */
+    private int $pos = 0;
+    /** @var Token[] Token array */
+    private array $tokens;
+    /** @var list<int> Token positions of comments */
+    private array $commentPositions = [];
+
+    /**
+     * Create a comment annotation visitor.
+     *
+     * @param Token[] $tokens Token array
+     */
+    public function __construct(array $tokens) {
+        $this->tokens = $tokens;
+
+        // Collect positions of comments. We use this to avoid traversing parts of the AST where
+        // there are no comments.
+        foreach ($tokens as $i => $token) {
+            if ($token->id === \T_COMMENT || $token->id === \T_DOC_COMMENT) {
+                $this->commentPositions[] = $i;
+            }
+        }
+    }
+
+    public function enterNode(Node $node) {
+        $nextCommentPos = current($this->commentPositions);
+        if ($nextCommentPos === false) {
+            // No more comments.
+            return self::STOP_TRAVERSAL;
+        }
+
+        $oldPos = $this->pos;
+        $this->pos = $pos = $node->getStartTokenPos();
+        if ($nextCommentPos > $oldPos && $nextCommentPos < $pos) {
+            $comments = [];
+            while (--$pos >= $oldPos) {
+                $token = $this->tokens[$pos];
+                if ($token->id === \T_DOC_COMMENT) {
+                    $comments[] = new Comment\Doc(
+                        $token->text, $token->line, $token->pos, $pos,
+                        $token->getEndLine(), $token->getEndPos() - 1, $pos);
+                    continue;
+                }
+                if ($token->id === \T_COMMENT) {
+                    $comments[] = new Comment(
+                        $token->text, $token->line, $token->pos, $pos,
+                        $token->getEndLine(), $token->getEndPos() - 1, $pos);
+                    continue;
+                }
+                if ($token->id !== \T_WHITESPACE) {
+                    break;
+                }
+            }
+            if (!empty($comments)) {
+                $node->setAttribute('comments', array_reverse($comments));
+            }
+
+            do {
+                $nextCommentPos = next($this->commentPositions);
+            } while ($nextCommentPos !== false && $nextCommentPos < $this->pos);
+        }
+
+        $endPos = $node->getEndTokenPos();
+        if ($nextCommentPos > $endPos) {
+            // Skip children if there are no comments located inside this node.
+            $this->pos = $endPos;
+            return self::DONT_TRAVERSE_CHILDREN;
+        }
+
+        return null;
+    }
+}

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php

@@ -9,12 +9,11 @@ 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 $foundNodes;
+    protected array $foundNodes;
 
     public function __construct(callable $filterCallback) {
         $this->filterCallback = $filterCallback;
@@ -27,11 +26,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) {
+    public function beforeTraverse(array $nodes): ?array {
         $this->foundNodes = [];
 
         return null;

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php

@@ -3,19 +3,18 @@
 namespace PhpParser\NodeVisitor;
 
 use PhpParser\Node;
-use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitor;
 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 $foundNode;
+    protected ?Node $foundNode;
 
     public function __construct(callable $filterCallback) {
         $this->filterCallback = $filterCallback;
@@ -28,11 +27,11 @@ class FirstFindingVisitor extends NodeVisitorAbstract
      *
      * @return null|Node Found node (or null if not found)
      */
-    public function getFoundNode() {
+    public function getFoundNode(): ?Node {
         return $this->foundNode;
     }
 
-    public function beforeTraverse(array $nodes) {
+    public function beforeTraverse(array $nodes): ?array {
         $this->foundNode = null;
 
         return null;
@@ -42,7 +41,7 @@ class FirstFindingVisitor extends NodeVisitorAbstract
         $filterCallback = $this->filterCallback;
         if ($filterCallback($node)) {
             $this->foundNode = $node;
-            return NodeTraverser::STOP_TRAVERSAL;
+            return NodeVisitor::STOP_TRAVERSAL;
         }
 
         return null;