@flarum/cli 2.0.0-beta.8 → 3.0.0

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/Name.php

@@ -4,12 +4,12 @@ namespace PhpParser\Node;
 
 use PhpParser\NodeAbstract;
 
-class Name extends NodeAbstract
-{
-    /** @var string[] Parts of the name */
-    public $parts;
+class Name extends NodeAbstract {
+    /** @var string Name as string */
+    public string $name;
 
-    private static $specialClassNames = [
+    /** @var array<string, bool> */
+    private static array $specialClassNames = [
         'self'   => true,
         'parent' => true,
         'static' => true,
@@ -18,16 +18,25 @@ class Name extends NodeAbstract
     /**
      * Constructs a name node.
      *
-     * @param string|string[]|self $name       Name as string, part array or Name instance (copy ctor)
-     * @param array                $attributes Additional attributes
+     * @param string|string[]|self $name Name as string, part array or Name instance (copy ctor)
+     * @param array<string, mixed> $attributes Additional attributes
      */
-    public function __construct($name, array $attributes = []) {
+    final public function __construct($name, array $attributes = []) {
         $this->attributes = $attributes;
-        $this->parts = self::prepareName($name);
+        $this->name = self::prepareName($name);
     }
 
-    public function getSubNodeNames() : array {
-        return ['parts'];
+    public function getSubNodeNames(): array {
+        return ['name'];
+    }
+
+    /**
+     * Get parts of name (split by the namespace separator).
+     *
+     * @return string[] Parts of name
+     */
+    public function getParts(): array {
+        return \explode('\\', $this->name);
     }
 
     /**
@@ -35,8 +44,11 @@ class Name extends NodeAbstract
      *
      * @return string First part of the name
      */
-    public function getFirst() : string {
-        return $this->parts[0];
+    public function getFirst(): string {
+        if (false !== $pos = \strpos($this->name, '\\')) {
+            return \substr($this->name, 0, $pos);
+        }
+        return $this->name;
     }
 
     /**
@@ -44,8 +56,11 @@ class Name extends NodeAbstract
      *
      * @return string Last part of the name
      */
-    public function getLast() : string {
-        return $this->parts[count($this->parts) - 1];
+    public function getLast(): string {
+        if (false !== $pos = \strrpos($this->name, '\\')) {
+            return \substr($this->name, $pos + 1);
+        }
+        return $this->name;
     }
 
     /**
@@ -53,8 +68,8 @@ class Name extends NodeAbstract
      *
      * @return bool Whether the name is unqualified
      */
-    public function isUnqualified() : bool {
-        return 1 === count($this->parts);
+    public function isUnqualified(): bool {
+        return false === \strpos($this->name, '\\');
     }
 
     /**
@@ -62,8 +77,8 @@ class Name extends NodeAbstract
      *
      * @return bool Whether the name is qualified
      */
-    public function isQualified() : bool {
-        return 1 < count($this->parts);
+    public function isQualified(): bool {
+        return false !== \strpos($this->name, '\\');
     }
 
     /**
@@ -71,7 +86,7 @@ class Name extends NodeAbstract
      *
      * @return bool Whether the name is fully qualified
      */
-    public function isFullyQualified() : bool {
+    public function isFullyQualified(): bool {
         return false;
     }
 
@@ -80,7 +95,7 @@ class Name extends NodeAbstract
      *
      * @return bool Whether the name is relative
      */
-    public function isRelative() : bool {
+    public function isRelative(): bool {
         return false;
     }
 
@@ -90,8 +105,8 @@ class Name extends NodeAbstract
      *
      * @return string String representation
      */
-    public function toString() : string {
-        return implode('\\', $this->parts);
+    public function toString(): string {
+        return $this->name;
     }
 
     /**
@@ -100,7 +115,7 @@ class Name extends NodeAbstract
      *
      * @return string String representation
      */
-    public function toCodeString() : string {
+    public function toCodeString(): string {
         return $this->toString();
     }
 
@@ -110,8 +125,8 @@ class Name extends NodeAbstract
      *
      * @return string Lowercased string representation
      */
-    public function toLowerString() : string {
-        return strtolower(implode('\\', $this->parts));
+    public function toLowerString(): string {
+        return strtolower($this->name);
     }
 
     /**
@@ -119,9 +134,8 @@ class Name extends NodeAbstract
      *
      * @return bool Whether identifier is a special class name
      */
-    public function isSpecialClassName() : bool {
-        return count($this->parts) === 1
-            && isset(self::$specialClassNames[strtolower($this->parts[0])]);
+    public function isSpecialClassName(): bool {
+        return isset(self::$specialClassNames[strtolower($this->name)]);
     }
 
     /**
@@ -130,8 +144,8 @@ class Name extends NodeAbstract
      *
      * @return string String representation
      */
-    public function __toString() : string {
-        return implode('\\', $this->parts);
+    public function __toString(): string {
+        return $this->name;
     }
 
     /**
@@ -145,13 +159,22 @@ class Name extends NodeAbstract
      *
      * Offset and length have the same meaning as in array_slice().
      *
-     * @param int      $offset Offset to start the slice at (may be negative)
+     * @param int $offset Offset to start the slice at (may be negative)
      * @param int|null $length Length of the slice (may be negative)
      *
      * @return static|null Sliced name
      */
-    public function slice(int $offset, int $length = null) {
-        $numParts = count($this->parts);
+    public function slice(int $offset, ?int $length = null) {
+        if ($offset === 1 && $length === null) {
+            // Short-circuit the common case.
+            if (false !== $pos = \strpos($this->name, '\\')) {
+                return new static(\substr($this->name, $pos + 1));
+            }
+            return null;
+        }
+
+        $parts = \explode('\\', $this->name);
+        $numParts = \count($parts);
 
         $realOffset = $offset < 0 ? $offset + $numParts : $offset;
         if ($realOffset < 0 || $realOffset > $numParts) {
@@ -162,7 +185,7 @@ class Name extends NodeAbstract
             $realLength = $numParts - $realOffset;
         } else {
             $realLength = $length < 0 ? $length + $numParts - $realOffset : $length;
-            if ($realLength < 0 || $realLength > $numParts) {
+            if ($realLength < 0 || $realLength > $numParts - $realOffset) {
                 throw new \OutOfBoundsException(sprintf('Length %d is out of bounds', $length));
             }
         }
@@ -172,7 +195,7 @@ class Name extends NodeAbstract
             return null;
         }
 
-        return new static(array_slice($this->parts, $realOffset, $realLength), $this->attributes);
+        return new static(array_slice($parts, $realOffset, $realLength), $this->attributes);
     }
 
     /**
@@ -186,49 +209,53 @@ class Name extends NodeAbstract
      *     Name::concat($namespace, $shortName)
      * where $namespace is a Name node or null will work as expected.
      *
-     * @param string|string[]|self|null $name1      The first name
-     * @param string|string[]|self|null $name2      The second name
-     * @param array                     $attributes Attributes to assign to concatenated name
+     * @param string|string[]|self|null $name1 The first name
+     * @param string|string[]|self|null $name2 The second name
+     * @param array<string, mixed> $attributes Attributes to assign to concatenated name
      *
      * @return static|null Concatenated name
      */
     public static function concat($name1, $name2, array $attributes = []) {
         if (null === $name1 && null === $name2) {
             return null;
-        } elseif (null === $name1) {
-            return new static(self::prepareName($name2), $attributes);
-        } elseif (null === $name2) {
-            return new static(self::prepareName($name1), $attributes);
+        }
+        if (null === $name1) {
+            return new static($name2, $attributes);
+        }
+        if (null === $name2) {
+            return new static($name1, $attributes);
         } else {
             return new static(
-                array_merge(self::prepareName($name1), self::prepareName($name2)), $attributes
+                self::prepareName($name1) . '\\' . self::prepareName($name2), $attributes
             );
         }
     }
 
     /**
      * Prepares a (string, array or Name node) name for use in name changing methods by converting
-     * it to an array.
+     * it to a string.
      *
      * @param string|string[]|self $name Name to prepare
      *
-     * @return string[] Prepared name
+     * @return string Prepared name
      */
-    private static function prepareName($name) : array {
+    private static function prepareName($name): string {
         if (\is_string($name)) {
             if ('' === $name) {
                 throw new \InvalidArgumentException('Name cannot be empty');
             }
 
-            return explode('\\', $name);
-        } elseif (\is_array($name)) {
+            return $name;
+        }
+        if (\is_array($name)) {
             if (empty($name)) {
                 throw new \InvalidArgumentException('Name cannot be empty');
             }
 
-            return $name;
-        } elseif ($name instanceof self) {
-            return $name->parts;
+            return implode('\\', $name);
+        }
+        if ($name instanceof self) {
+            return $name->name;
         }
 
         throw new \InvalidArgumentException(
@@ -236,7 +263,7 @@ class Name extends NodeAbstract
         );
     }
 
-    public function getType() : string {
+    public function getType(): string {
         return 'Name';
     }
 }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/NullableType.php

@@ -2,29 +2,28 @@
 
 namespace PhpParser\Node;
 
-use PhpParser\NodeAbstract;
+use PhpParser\Node;
 
-class NullableType extends NodeAbstract
-{
+class NullableType extends ComplexType {
     /** @var Identifier|Name Type */
-    public $type;
+    public Node $type;
 
     /**
      * Constructs a nullable type (wrapping another type).
      *
-     * @param string|Identifier|Name $type       Type
-     * @param array                  $attributes Additional attributes
+     * @param Identifier|Name $type Type
+     * @param array<string, mixed> $attributes Additional attributes
      */
-    public function __construct($type, array $attributes = []) {
+    public function __construct(Node $type, array $attributes = []) {
         $this->attributes = $attributes;
-        $this->type = \is_string($type) ? new Identifier($type) : $type;
+        $this->type = $type;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['type'];
     }
-    
-    public function getType() : string {
+
+    public function getType(): string {
         return 'NullableType';
     }
 }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/Param.php

@@ -2,46 +2,47 @@
 
 namespace PhpParser\Node;
 
+use PhpParser\Modifiers;
+use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class Param extends NodeAbstract
-{
-    /** @var null|Identifier|Name|NullableType|UnionType Type declaration */
-    public $type;
+class Param extends NodeAbstract {
+    /** @var null|Identifier|Name|ComplexType Type declaration */
+    public ?Node $type;
     /** @var bool Whether parameter is passed by reference */
-    public $byRef;
+    public bool $byRef;
     /** @var bool Whether this is a variadic argument */
-    public $variadic;
+    public bool $variadic;
     /** @var Expr\Variable|Expr\Error Parameter variable */
-    public $var;
+    public Expr $var;
     /** @var null|Expr Default value */
-    public $default;
-    /** @var int */
-    public $flags;
+    public ?Expr $default;
+    /** @var int Optional visibility flags */
+    public int $flags;
     /** @var AttributeGroup[] PHP attribute groups */
-    public $attrGroups;
+    public array $attrGroups;
 
     /**
      * Constructs a parameter node.
      *
-     * @param Expr\Variable|Expr\Error                           $var        Parameter variable
-     * @param null|Expr                                          $default    Default value
-     * @param null|string|Identifier|Name|NullableType|UnionType $type       Type declaration
-     * @param bool                                               $byRef      Whether is passed by reference
-     * @param bool                                               $variadic   Whether this is a variadic argument
-     * @param array                                              $attributes Additional attributes
-     * @param int                                                $flags      Optional visibility flags
-     * @param AttributeGroup[]                                   $attrGroups PHP attribute groups
+     * @param Expr\Variable|Expr\Error $var Parameter variable
+     * @param null|Expr $default Default value
+     * @param null|Identifier|Name|ComplexType $type Type declaration
+     * @param bool $byRef Whether is passed by reference
+     * @param bool $variadic Whether this is a variadic argument
+     * @param array<string, mixed> $attributes Additional attributes
+     * @param int $flags Optional visibility flags
+     * @param list<AttributeGroup> $attrGroups PHP attribute groups
      */
     public function __construct(
-        $var, Expr $default = null, $type = null,
+        Expr $var, ?Expr $default = null, ?Node $type = null,
         bool $byRef = false, bool $variadic = false,
         array $attributes = [],
         int $flags = 0,
         array $attrGroups = []
     ) {
         $this->attributes = $attributes;
-        $this->type = \is_string($type) ? new Identifier($type) : $type;
+        $this->type = $type;
         $this->byRef = $byRef;
         $this->variadic = $variadic;
         $this->var = $var;
@@ -50,11 +51,34 @@ class Param extends NodeAbstract
         $this->attrGroups = $attrGroups;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['attrGroups', 'flags', 'type', 'byRef', 'variadic', 'var', 'default'];
     }
 
-    public function getType() : string {
+    public function getType(): string {
         return 'Param';
     }
+
+    /**
+     * Whether this parameter uses constructor property promotion.
+     */
+    public function isPromoted(): bool {
+        return $this->flags !== 0;
+    }
+
+    public function isPublic(): bool {
+        return (bool) ($this->flags & Modifiers::PUBLIC);
+    }
+
+    public function isProtected(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED);
+    }
+
+    public function isPrivate(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE);
+    }
+
+    public function isReadonly(): bool {
+        return (bool) ($this->flags & Modifiers::READONLY);
+    }
 }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyItem.php

@@ -0,0 +1,37 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class PropertyItem extends NodeAbstract {
+    /** @var Node\VarLikeIdentifier Name */
+    public VarLikeIdentifier $name;
+    /** @var null|Node\Expr Default */
+    public ?Expr $default;
+
+    /**
+     * Constructs a class property item node.
+     *
+     * @param string|Node\VarLikeIdentifier $name Name
+     * @param null|Node\Expr $default Default value
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct($name, ?Node\Expr $default = null, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->name = \is_string($name) ? new Node\VarLikeIdentifier($name) : $name;
+        $this->default = $default;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['name', 'default'];
+    }
+
+    public function getType(): string {
+        return 'PropertyItem';
+    }
+}
+
+// @deprecated compatibility alias
+class_alias(PropertyItem::class, Stmt\PropertyProperty::class);

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/DNumber.php

@@ -1,70 +1,3 @@
 <?php declare(strict_types=1);
 
-namespace PhpParser\Node\Scalar;
-
-use PhpParser\Node\Scalar;
-
-class DNumber extends Scalar
-{
-    /** @var float Number value */
-    public $value;
-
-    /**
-     * Constructs a float number scalar node.
-     *
-     * @param float $value      Value of the number
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(float $value, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->value = $value;
-    }
-
-    public function getSubNodeNames() : array {
-        return ['value'];
-    }
-
-    /**
-     * @internal
-     *
-     * Parses a DNUMBER token like PHP would.
-     *
-     * @param string $str A string number
-     *
-     * @return float The parsed number
-     */
-    public static function parse(string $str) : float {
-        $str = str_replace('_', '', $str);
-
-        // if string contains any of .eE just cast it to float
-        if (false !== strpbrk($str, '.eE')) {
-            return (float) $str;
-        }
-
-        // otherwise it's an integer notation that overflowed into a float
-        // if it starts with 0 it's one of the special integer notations
-        if ('0' === $str[0]) {
-            // hex
-            if ('x' === $str[1] || 'X' === $str[1]) {
-                return hexdec($str);
-            }
-
-            // bin
-            if ('b' === $str[1] || 'B' === $str[1]) {
-                return bindec($str);
-            }
-
-            // oct
-            // substr($str, 0, strcspn($str, '89')) cuts the string at the first invalid digit (8 or 9)
-            // so that only the digits before that are used
-            return octdec(substr($str, 0, strcspn($str, '89')));
-        }
-
-        // dec
-        return (float) $str;
-    }
-    
-    public function getType() : string {
-        return 'Scalar_DNumber';
-    }
-}
+require __DIR__ . '/Float_.php';

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/Encapsed.php

@@ -1,31 +1,3 @@
 <?php declare(strict_types=1);
 
-namespace PhpParser\Node\Scalar;
-
-use PhpParser\Node\Expr;
-use PhpParser\Node\Scalar;
-
-class Encapsed extends Scalar
-{
-    /** @var Expr[] list of string parts */
-    public $parts;
-
-    /**
-     * Constructs an encapsed string node.
-     *
-     * @param Expr[] $parts      Encaps list
-     * @param array  $attributes Additional attributes
-     */
-    public function __construct(array $parts, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->parts = $parts;
-    }
-
-    public function getSubNodeNames() : array {
-        return ['parts'];
-    }
-    
-    public function getType() : string {
-        return 'Scalar_Encapsed';
-    }
-}
+require __DIR__ . '/InterpolatedString.php';

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/EncapsedStringPart.php

@@ -1,30 +1,3 @@
 <?php declare(strict_types=1);
 
-namespace PhpParser\Node\Scalar;
-
-use PhpParser\Node\Scalar;
-
-class EncapsedStringPart extends Scalar
-{
-    /** @var string String value */
-    public $value;
-
-    /**
-     * Constructs a node representing a string part of an encapsed string.
-     *
-     * @param string $value      String value
-     * @param array  $attributes Additional attributes
-     */
-    public function __construct(string $value, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->value = $value;
-    }
-
-    public function getSubNodeNames() : array {
-        return ['value'];
-    }
-    
-    public function getType() : string {
-        return 'Scalar_EncapsedStringPart';
-    }
-}
+require __DIR__ . '/../InterpolatedStringPart.php';

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/Float_.php

@@ -0,0 +1,78 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+use PhpParser\Node\Scalar;
+
+class Float_ extends Scalar {
+    /** @var float Number value */
+    public float $value;
+
+    /**
+     * Constructs a float number scalar node.
+     *
+     * @param float $value Value of the number
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(float $value, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['value'];
+    }
+
+    /**
+     * @param mixed[] $attributes
+     */
+    public static function fromString(string $str, array $attributes = []): Float_ {
+        $attributes['rawValue'] = $str;
+        $float = self::parse($str);
+
+        return new Float_($float, $attributes);
+    }
+
+    /**
+     * @internal
+     *
+     * Parses a DNUMBER token like PHP would.
+     *
+     * @param string $str A string number
+     *
+     * @return float The parsed number
+     */
+    public static function parse(string $str): float {
+        $str = str_replace('_', '', $str);
+
+        // Check whether this is one of the special integer notations.
+        if ('0' === $str[0]) {
+            // hex
+            if ('x' === $str[1] || 'X' === $str[1]) {
+                return hexdec($str);
+            }
+
+            // bin
+            if ('b' === $str[1] || 'B' === $str[1]) {
+                return bindec($str);
+            }
+
+            // oct, but only if the string does not contain any of '.eE'.
+            if (false === strpbrk($str, '.eE')) {
+                // substr($str, 0, strcspn($str, '89')) cuts the string at the first invalid digit
+                // (8 or 9) so that only the digits before that are used.
+                return octdec(substr($str, 0, strcspn($str, '89')));
+            }
+        }
+
+        // dec
+        return (float) $str;
+    }
+
+    public function getType(): string {
+        return 'Scalar_Float';
+    }
+}
+
+// @deprecated compatibility alias
+class_alias(Float_::class, DNumber::class);