@flarum/cli 2.0.0-beta.8 → 3.0.0

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

@@ -11,16 +11,15 @@ 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;
+    protected NameContext $nameContext;
 
     /** @var bool Whether to preserve original names */
-    protected $preserveOriginalNames;
+    protected bool $preserveOriginalNames;
 
     /** @var bool Whether to replace resolved nodes in place, or to add resolvedNode attributes */
-    protected $replaceNodes;
+    protected bool $replaceNodes;
 
     /**
      * Constructs a name resolution visitor.
@@ -33,24 +32,22 @@ class NameResolver extends NodeVisitorAbstract
      *    namespacedName attribute, as usual.)
      *
      * @param ErrorHandler|null $errorHandler Error handler
-     * @param array $options Options
+     * @param array{preserveOriginalNames?: bool, replaceNodes?: bool} $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) {
+    public function beforeTraverse(array $nodes): ?array {
         $this->nameContext->startNamespace();
         return null;
     }
@@ -78,12 +75,21 @@ 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) {
                 $interface = $this->resolveClassName($interface);
             }
 
+            $this->resolveAttrGroups($node);
+            $this->addNamespacedName($node);
+        } elseif ($node instanceof Stmt\Enum_) {
+            foreach ($node->implements as &$interface) {
+                $interface = $this->resolveClassName($interface);
+            }
+
             $this->resolveAttrGroups($node);
             $this->addNamespacedName($node);
         } elseif ($node instanceof Stmt\Trait_) {
@@ -108,7 +114,12 @@ class NameResolver extends NodeVisitorAbstract
             foreach ($node->consts as $const) {
                 $this->addNamespacedName($const);
             }
-        } else if ($node instanceof Stmt\ClassConst) {
+        } elseif ($node instanceof Stmt\ClassConst) {
+            if (null !== $node->type) {
+                $node->type = $this->resolveType($node->type);
+            }
+            $this->resolveAttrGroups($node);
+        } elseif ($node instanceof Stmt\EnumCase) {
             $this->resolveAttrGroups($node);
         } elseif ($node instanceof Expr\StaticCall
                   || $node instanceof Expr\StaticPropertyFetch
@@ -150,7 +161,8 @@ class NameResolver extends NodeVisitorAbstract
         return null;
     }
 
-    private function addAlias(Stmt\UseUse $use, $type, Name $prefix = null) {
+    /** @param Stmt\Use_::TYPE_* $type */
+    private function addAlias(Node\UseItem $use, int $type, ?Name $prefix = null): void {
         // 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
@@ -161,8 +173,8 @@ class NameResolver extends NodeVisitorAbstract
         );
     }
 
-    /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure $node */
-    private function resolveSignature($node) {
+    /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure|Expr\ArrowFunction $node */
+    private function resolveSignature($node): void {
         foreach ($node->params as $param) {
             $param->type = $this->resolveType($param->type);
             $this->resolveAttrGroups($param);
@@ -170,7 +182,12 @@ class NameResolver extends NodeVisitorAbstract
         $node->returnType = $this->resolveType($node->returnType);
     }
 
-    private function resolveType($node) {
+    /**
+     * @template T of Node\Identifier|Name|Node\ComplexType|null
+     * @param T $node
+     * @return T
+     */
+    private function resolveType(?Node $node): ?Node {
         if ($node instanceof Name) {
             return $this->resolveClassName($node);
         }
@@ -178,7 +195,7 @@ class NameResolver extends NodeVisitorAbstract
             $node->type = $this->resolveType($node->type);
             return $node;
         }
-        if ($node instanceof Node\UnionType) {
+        if ($node instanceof Node\UnionType || $node instanceof Node\IntersectionType) {
             foreach ($node->types as &$type) {
                 $type = $this->resolveType($type);
             }
@@ -191,11 +208,11 @@ class NameResolver extends NodeVisitorAbstract
      * Resolve name, according to name resolver options.
      *
      * @param Name $name Function or constant name to resolve
-     * @param int  $type One of Stmt\Use_::TYPE_*
+     * @param Stmt\Use_::TYPE_* $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) {
@@ -226,17 +243,16 @@ class NameResolver extends NodeVisitorAbstract
         return $name;
     }
 
-    protected function resolveClassName(Name $name) {
+    protected function resolveClassName(Name $name): Name {
         return $this->resolveName($name, Stmt\Use_::TYPE_NORMAL);
     }
 
-    protected function addNamespacedName(Node $node) {
+    protected function addNamespacedName(Node $node): void {
         $node->namespacedName = Name::concat(
             $this->nameContext->getNamespace(), (string) $node->name);
     }
 
-    protected function resolveAttrGroups(Node $node)
-    {
+    protected function resolveAttrGroups(Node $node): void {
         foreach ($node->attrGroups as $attrGroup) {
             foreach ($attrGroup->attrs as $attr) {
                 $attr->name = $this->resolveClassName($attr->name);

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

@@ -14,12 +14,11 @@ 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 $stack = [];
+    private array $stack = [];
 
     /**
      * @var ?Node

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

@@ -2,31 +2,29 @@
 
 namespace PhpParser\NodeVisitor;
 
-use function array_pop;
-use function count;
 use PhpParser\Node;
 use PhpParser\NodeVisitorAbstract;
 
+use function array_pop;
+use function count;
+
 /**
  * Visitor that connects a child node to its parent node.
  *
  * 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 $stack = [];
+    private array $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]);
         }
@@ -34,8 +32,7 @@ final class ParentConnectingVisitor extends NodeVisitorAbstract
         $this->stack[] = $node;
     }
 
-    public function leaveNode(Node $node)
-    {
+    public function leaveNode(Node $node) {
         array_pop($this->stack);
     }
 }

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

@@ -2,8 +2,49 @@
 
 namespace PhpParser;
 
-interface NodeVisitor
-{
+interface NodeVisitor {
+    /**
+     * 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 = 1;
+
+    /**
+     * If NodeVisitor::enterNode() or NodeVisitor::leaveNode() returns
+     * STOP_TRAVERSAL, traversal is aborted.
+     *
+     * The afterTraverse() method will still be invoked.
+     */
+    public const STOP_TRAVERSAL = 2;
+
+    /**
+     * 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 = 3;
+
+    /**
+     * 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 = 4;
+
+    /**
+     * If NodeVisitor::enterNode() or NodeVisitor::leaveNode() returns REPLACE_WITH_NULL,
+     * the node will be replaced with null. This is not a legal return value if the node is part
+     * of an array, rather than another node.
+     */
+    public const REPLACE_WITH_NULL = 5;
+
     /**
      * Called once before traversal.
      *
@@ -23,16 +64,25 @@ interface NodeVisitor
      * Return value semantics:
      *  * null
      *        => $node stays as-is
-     *  * NodeTraverser::DONT_TRAVERSE_CHILDREN
+     *  * array (of Nodes)
+     *        => The return value is merged into the parent array (at the position of the $node)
+     *  * NodeVisitor::REMOVE_NODE
+     *        => $node is removed from the parent array
+     *  * NodeVisitor::REPLACE_WITH_NULL
+     *        => $node is replaced with null
+     *  * NodeVisitor::DONT_TRAVERSE_CHILDREN
      *        => Children of $node are not traversed. $node stays as-is
-     *  * NodeTraverser::STOP_TRAVERSAL
+     *  * NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN
+     *        => Further visitors for the current node are skipped, and its children are not
+     *           traversed. $node stays as-is.
+     *  * NodeVisitor::STOP_TRAVERSAL
      *        => Traversal is aborted. $node stays as-is
      *  * otherwise
      *        => $node is set to the return value
      *
      * @param Node $node Node
      *
-     * @return null|int|Node Replacement node (or special return value)
+     * @return null|int|Node|Node[] Replacement node (or special return value)
      */
     public function enterNode(Node $node);
 
@@ -42,9 +92,11 @@ interface NodeVisitor
      * Return value semantics:
      *  * null
      *        => $node stays as-is
-     *  * NodeTraverser::REMOVE_NODE
+     *  * NodeVisitor::REMOVE_NODE
      *        => $node is removed from the parent array
-     *  * NodeTraverser::STOP_TRAVERSAL
+     *  * NodeVisitor::REPLACE_WITH_NULL
+     *        => $node is replaced with null
+     *  * NodeVisitor::STOP_TRAVERSAL
      *        => Traversal is aborted. $node stays as-is
      *  * array (of Nodes)
      *        => The return value is merged into the parent array (at the position of the $node)

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

@@ -5,8 +5,7 @@ namespace PhpParser;
 /**
  * @codeCoverageIgnore
  */
-class NodeVisitorAbstract implements NodeVisitor
-{
+abstract class NodeVisitorAbstract implements NodeVisitor {
     public function beforeTraverse(array $nodes) {
         return null;
     }