@appthreat/atom 1.8.1 → 1.8.2

package/plugins/nikic/php-parser/lib/PhpParser/Node/MatchArm.php

@@ -5,26 +5,27 @@ namespace PhpParser\Node;
 use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class MatchArm extends NodeAbstract {
-    /** @var null|list<Node\Expr> */
-    public ?array $conds;
+class MatchArm extends NodeAbstract
+{
+    /** @var null|Node\Expr[] */
+    public $conds;
     /** @var Node\Expr */
-    public Expr $body;
+    public $body;
 
     /**
-     * @param null|list<Node\Expr> $conds
+     * @param null|Node\Expr[] $conds
      */
-    public function __construct(?array $conds, Node\Expr $body, array $attributes = []) {
+    public function __construct($conds, Node\Expr $body, array $attributes = []) {
         $this->conds = $conds;
         $this->body = $body;
         $this->attributes = $attributes;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['conds', 'body'];
     }
 
-    public function getType(): string {
+    public function getType() : string {
         return 'MatchArm';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php

@@ -2,13 +2,14 @@
 
 namespace PhpParser\Node\Name;
 
-class FullyQualified extends \PhpParser\Node\Name {
+class FullyQualified extends \PhpParser\Node\Name
+{
     /**
      * Checks whether the name is unqualified. (E.g. Name)
      *
      * @return bool Whether the name is unqualified
      */
-    public function isUnqualified(): bool {
+    public function isUnqualified() : bool {
         return false;
     }
 
@@ -17,7 +18,7 @@ class FullyQualified extends \PhpParser\Node\Name {
      *
      * @return bool Whether the name is qualified
      */
-    public function isQualified(): bool {
+    public function isQualified() : bool {
         return false;
     }
 
@@ -26,7 +27,7 @@ class FullyQualified extends \PhpParser\Node\Name {
      *
      * @return bool Whether the name is fully qualified
      */
-    public function isFullyQualified(): bool {
+    public function isFullyQualified() : bool {
         return true;
     }
 
@@ -35,15 +36,15 @@ class FullyQualified extends \PhpParser\Node\Name {
      *
      * @return bool Whether the name is relative
      */
-    public function isRelative(): bool {
+    public function isRelative() : bool {
         return false;
     }
 
-    public function toCodeString(): string {
+    public function toCodeString() : string {
         return '\\' . $this->toString();
     }
-
-    public function getType(): string {
+    
+    public function getType() : string {
         return 'Name_FullyQualified';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php

@@ -2,13 +2,14 @@
 
 namespace PhpParser\Node\Name;
 
-class Relative extends \PhpParser\Node\Name {
+class Relative extends \PhpParser\Node\Name
+{
     /**
      * Checks whether the name is unqualified. (E.g. Name)
      *
      * @return bool Whether the name is unqualified
      */
-    public function isUnqualified(): bool {
+    public function isUnqualified() : bool {
         return false;
     }
 
@@ -17,7 +18,7 @@ class Relative extends \PhpParser\Node\Name {
      *
      * @return bool Whether the name is qualified
      */
-    public function isQualified(): bool {
+    public function isQualified() : bool {
         return false;
     }
 
@@ -26,7 +27,7 @@ class Relative extends \PhpParser\Node\Name {
      *
      * @return bool Whether the name is fully qualified
      */
-    public function isFullyQualified(): bool {
+    public function isFullyQualified() : bool {
         return false;
     }
 
@@ -35,15 +36,15 @@ class Relative extends \PhpParser\Node\Name {
      *
      * @return bool Whether the name is relative
      */
-    public function isRelative(): bool {
+    public function isRelative() : bool {
         return true;
     }
 
-    public function toCodeString(): string {
+    public function toCodeString() : string {
         return 'namespace\\' . $this->toString();
     }
-
-    public function getType(): string {
+    
+    public function getType() : string {
         return 'Name_Relative';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Name.php

@@ -4,12 +4,15 @@ namespace PhpParser\Node;
 
 use PhpParser\NodeAbstract;
 
-class Name extends NodeAbstract {
-    /** @var string Name as string */
-    public string $name;
+class Name extends NodeAbstract
+{
+    /**
+     * @var string[] Parts of the name
+     * @deprecated Use getParts() instead
+     */
+    public $parts;
 
-    /** @var array<string, bool> */
-    private static array $specialClassNames = [
+    private static $specialClassNames = [
         'self'   => true,
         'parent' => true,
         'static' => true,
@@ -18,16 +21,16 @@ 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<string, mixed> $attributes Additional attributes
+     * @param string|string[]|self $name       Name as string, part array or Name instance (copy ctor)
+     * @param array                $attributes Additional attributes
      */
-    final public function __construct($name, array $attributes = []) {
+    public function __construct($name, array $attributes = []) {
         $this->attributes = $attributes;
-        $this->name = self::prepareName($name);
+        $this->parts = self::prepareName($name);
     }
 
-    public function getSubNodeNames(): array {
-        return ['name'];
+    public function getSubNodeNames() : array {
+        return ['parts'];
     }
 
     /**
@@ -36,7 +39,7 @@ class Name extends NodeAbstract {
      * @return string[] Parts of name
      */
     public function getParts(): array {
-        return \explode('\\', $this->name);
+        return $this->parts;
     }
 
     /**
@@ -44,11 +47,8 @@ class Name extends NodeAbstract {
      *
      * @return string First part of the name
      */
-    public function getFirst(): string {
-        if (false !== $pos = \strpos($this->name, '\\')) {
-            return \substr($this->name, 0, $pos);
-        }
-        return $this->name;
+    public function getFirst() : string {
+        return $this->parts[0];
     }
 
     /**
@@ -56,11 +56,8 @@ class Name extends NodeAbstract {
      *
      * @return string Last part of the name
      */
-    public function getLast(): string {
-        if (false !== $pos = \strrpos($this->name, '\\')) {
-            return \substr($this->name, $pos + 1);
-        }
-        return $this->name;
+    public function getLast() : string {
+        return $this->parts[count($this->parts) - 1];
     }
 
     /**
@@ -68,8 +65,8 @@ class Name extends NodeAbstract {
      *
      * @return bool Whether the name is unqualified
      */
-    public function isUnqualified(): bool {
-        return false === \strpos($this->name, '\\');
+    public function isUnqualified() : bool {
+        return 1 === count($this->parts);
     }
 
     /**
@@ -77,8 +74,8 @@ class Name extends NodeAbstract {
      *
      * @return bool Whether the name is qualified
      */
-    public function isQualified(): bool {
-        return false !== \strpos($this->name, '\\');
+    public function isQualified() : bool {
+        return 1 < count($this->parts);
     }
 
     /**
@@ -86,7 +83,7 @@ class Name extends NodeAbstract {
      *
      * @return bool Whether the name is fully qualified
      */
-    public function isFullyQualified(): bool {
+    public function isFullyQualified() : bool {
         return false;
     }
 
@@ -95,7 +92,7 @@ class Name extends NodeAbstract {
      *
      * @return bool Whether the name is relative
      */
-    public function isRelative(): bool {
+    public function isRelative() : bool {
         return false;
     }
 
@@ -105,8 +102,8 @@ class Name extends NodeAbstract {
      *
      * @return string String representation
      */
-    public function toString(): string {
-        return $this->name;
+    public function toString() : string {
+        return implode('\\', $this->parts);
     }
 
     /**
@@ -115,7 +112,7 @@ class Name extends NodeAbstract {
      *
      * @return string String representation
      */
-    public function toCodeString(): string {
+    public function toCodeString() : string {
         return $this->toString();
     }
 
@@ -125,8 +122,8 @@ class Name extends NodeAbstract {
      *
      * @return string Lowercased string representation
      */
-    public function toLowerString(): string {
-        return strtolower($this->name);
+    public function toLowerString() : string {
+        return strtolower(implode('\\', $this->parts));
     }
 
     /**
@@ -134,8 +131,9 @@ class Name extends NodeAbstract {
      *
      * @return bool Whether identifier is a special class name
      */
-    public function isSpecialClassName(): bool {
-        return isset(self::$specialClassNames[strtolower($this->name)]);
+    public function isSpecialClassName() : bool {
+        return count($this->parts) === 1
+            && isset(self::$specialClassNames[strtolower($this->parts[0])]);
     }
 
     /**
@@ -144,8 +142,8 @@ class Name extends NodeAbstract {
      *
      * @return string String representation
      */
-    public function __toString(): string {
-        return $this->name;
+    public function __toString() : string {
+        return implode('\\', $this->parts);
     }
 
     /**
@@ -159,22 +157,13 @@ 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) {
-        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);
+    public function slice(int $offset, int $length = null) {
+        $numParts = count($this->parts);
 
         $realOffset = $offset < 0 ? $offset + $numParts : $offset;
         if ($realOffset < 0 || $realOffset > $numParts) {
@@ -195,7 +184,7 @@ class Name extends NodeAbstract {
             return null;
         }
 
-        return new static(array_slice($parts, $realOffset, $realLength), $this->attributes);
+        return new static(array_slice($this->parts, $realOffset, $realLength), $this->attributes);
     }
 
     /**
@@ -209,53 +198,49 @@ 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<string, mixed> $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                     $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;
-        }
-        if (null === $name1) {
-            return new static($name2, $attributes);
-        }
-        if (null === $name2) {
-            return new static($name1, $attributes);
+        } elseif (null === $name1) {
+            return new static(self::prepareName($name2), $attributes);
+        } elseif (null === $name2) {
+            return new static(self::prepareName($name1), $attributes);
         } else {
             return new static(
-                self::prepareName($name1) . '\\' . self::prepareName($name2), $attributes
+                array_merge(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 a string.
+     * it to an array.
      *
      * @param string|string[]|self $name Name to prepare
      *
-     * @return string Prepared name
+     * @return string[] Prepared name
      */
-    private static function prepareName($name): string {
+    private static function prepareName($name) : array {
         if (\is_string($name)) {
             if ('' === $name) {
                 throw new \InvalidArgumentException('Name cannot be empty');
             }
 
-            return $name;
-        }
-        if (\is_array($name)) {
+            return explode('\\', $name);
+        } elseif (\is_array($name)) {
             if (empty($name)) {
                 throw new \InvalidArgumentException('Name cannot be empty');
             }
 
-            return implode('\\', $name);
-        }
-        if ($name instanceof self) {
-            return $name->name;
+            return $name;
+        } elseif ($name instanceof self) {
+            return $name->parts;
         }
 
         throw new \InvalidArgumentException(
@@ -263,7 +248,7 @@ class Name extends NodeAbstract {
         );
     }
 
-    public function getType(): string {
+    public function getType() : string {
         return 'Name';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/NullableType.php

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

package/plugins/nikic/php-parser/lib/PhpParser/Node/Param.php

@@ -2,47 +2,46 @@
 
 namespace PhpParser\Node;
 
-use PhpParser\Modifiers;
-use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class Param extends NodeAbstract {
+class Param extends NodeAbstract
+{
     /** @var null|Identifier|Name|ComplexType Type declaration */
-    public ?Node $type;
+    public $type;
     /** @var bool Whether parameter is passed by reference */
-    public bool $byRef;
+    public $byRef;
     /** @var bool Whether this is a variadic argument */
-    public bool $variadic;
+    public $variadic;
     /** @var Expr\Variable|Expr\Error Parameter variable */
-    public Expr $var;
+    public $var;
     /** @var null|Expr Default value */
-    public ?Expr $default;
-    /** @var int Optional visibility flags */
-    public int $flags;
+    public $default;
+    /** @var int */
+    public $flags;
     /** @var AttributeGroup[] PHP attribute groups */
-    public array $attrGroups;
+    public $attrGroups;
 
     /**
      * Constructs a parameter node.
      *
-     * @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
+     * @param Expr\Variable|Expr\Error                $var        Parameter variable
+     * @param null|Expr                               $default    Default value
+     * @param null|string|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                                   $attributes Additional attributes
+     * @param int                                     $flags      Optional visibility flags
+     * @param AttributeGroup[]                        $attrGroups PHP attribute groups
      */
     public function __construct(
-        Expr $var, ?Expr $default = null, ?Node $type = null,
+        $var, Expr $default = null, $type = null,
         bool $byRef = false, bool $variadic = false,
         array $attributes = [],
         int $flags = 0,
         array $attrGroups = []
     ) {
         $this->attributes = $attributes;
-        $this->type = $type;
+        $this->type = \is_string($type) ? new Identifier($type) : $type;
         $this->byRef = $byRef;
         $this->variadic = $variadic;
         $this->var = $var;
@@ -51,34 +50,11 @@ 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/plugins/nikic/php-parser/lib/PhpParser/Node/Scalar/DNumber.php

@@ -1,3 +1,77 @@
 <?php declare(strict_types=1);
 
-require __DIR__ . '/Float_.php';
+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'];
+    }
+
+    /**
+     * @param mixed[] $attributes
+     */
+    public static function fromString(string $str, array $attributes = []): DNumber
+    {
+        $attributes['rawValue'] = $str;
+        $float = self::parse($str);
+
+        return new DNumber($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_DNumber';
+    }
+}

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

@@ -1,3 +1,31 @@
 <?php declare(strict_types=1);
 
-require __DIR__ . '/InterpolatedString.php';
+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';
+    }
+}