@appthreat/atom-parsetools 1.0.4 → 1.0.6

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

@@ -5,18 +5,18 @@ namespace PhpParser\Node\Scalar;
 use PhpParser\Error;
 use PhpParser\Node\Scalar;
 
-class String_ extends Scalar
-{
+class String_ extends Scalar {
     /* For use in "kind" attribute */
-    const KIND_SINGLE_QUOTED = 1;
-    const KIND_DOUBLE_QUOTED = 2;
-    const KIND_HEREDOC = 3;
-    const KIND_NOWDOC = 4;
+    public const KIND_SINGLE_QUOTED = 1;
+    public const KIND_DOUBLE_QUOTED = 2;
+    public const KIND_HEREDOC = 3;
+    public const KIND_NOWDOC = 4;
 
     /** @var string String value */
-    public $value;
+    public string $value;
 
-    protected static $replacements = [
+    /** @var array<string, string> Escaped character to its decoded value */
+    protected static array $replacements = [
         '\\' => '\\',
         '$'  =>  '$',
         'n'  => "\n",
@@ -30,23 +30,23 @@ class String_ extends Scalar
     /**
      * Constructs a string scalar node.
      *
-     * @param string $value      Value of the string
-     * @param array  $attributes Additional attributes
+     * @param string $value Value of the string
+     * @param array<string, mixed> $attributes Additional attributes
      */
     public function __construct(string $value, array $attributes = []) {
         $this->attributes = $attributes;
         $this->value = $value;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['value'];
     }
 
     /**
+     * @param array<string, mixed> $attributes
      * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
      */
-    public static function fromString(string $str, array $attributes = [], bool $parseUnicodeEscape = true): self
-    {
+    public static function fromString(string $str, array $attributes = [], bool $parseUnicodeEscape = true): self {
         $attributes['kind'] = ($str[0] === "'" || ($str[1] === "'" && ($str[0] === 'b' || $str[0] === 'B')))
             ? Scalar\String_::KIND_SINGLE_QUOTED
             : Scalar\String_::KIND_DOUBLE_QUOTED;
@@ -68,7 +68,7 @@ class String_ extends Scalar
      *
      * @return string The parsed string
      */
-    public static function parse(string $str, bool $parseUnicodeEscape = true) : string {
+    public static function parse(string $str, bool $parseUnicodeEscape = true): string {
         $bLength = 0;
         if ('b' === $str[0] || 'B' === $str[0]) {
             $bLength = 1;
@@ -92,13 +92,13 @@ class String_ extends Scalar
      *
      * Parses escape sequences in strings (all string types apart from single quoted).
      *
-     * @param string      $str   String without quotes
+     * @param string $str String without quotes
      * @param null|string $quote Quote type
      * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
      *
      * @return string String with escape sequences parsed
      */
-    public static function parseEscapeSequences(string $str, $quote, bool $parseUnicodeEscape = true) : string {
+    public static function parseEscapeSequences(string $str, ?string $quote, bool $parseUnicodeEscape = true): string {
         if (null !== $quote) {
             $str = str_replace('\\' . $quote, $quote, $str);
         }
@@ -110,15 +110,19 @@ class String_ extends Scalar
 
         return preg_replace_callback(
             '~\\\\([\\\\$nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}' . $extra . ')~',
-            function($matches) {
+            function ($matches) {
                 $str = $matches[1];
 
                 if (isset(self::$replacements[$str])) {
                     return self::$replacements[$str];
-                } elseif ('x' === $str[0] || 'X' === $str[0]) {
+                }
+                if ('x' === $str[0] || 'X' === $str[0]) {
                     return chr(hexdec(substr($str, 1)));
-                } elseif ('u' === $str[0]) {
-                    return self::codePointToUtf8(hexdec($matches[2]));
+                }
+                if ('u' === $str[0]) {
+                    $dec = hexdec($matches[2]);
+                    // If it overflowed to float, treat as INT_MAX, it will throw an error anyway.
+                    return self::codePointToUtf8(\is_int($dec) ? $dec : \PHP_INT_MAX);
                 } else {
                     return chr(octdec($str));
                 }
@@ -134,24 +138,24 @@ class String_ extends Scalar
      *
      * @return string UTF-8 representation of code point
      */
-    private static function codePointToUtf8(int $num) : string {
+    private static function codePointToUtf8(int $num): string {
         if ($num <= 0x7F) {
             return chr($num);
         }
         if ($num <= 0x7FF) {
-            return chr(($num>>6) + 0xC0) . chr(($num&0x3F) + 0x80);
+            return chr(($num >> 6) + 0xC0) . chr(($num & 0x3F) + 0x80);
         }
         if ($num <= 0xFFFF) {
-            return chr(($num>>12) + 0xE0) . chr((($num>>6)&0x3F) + 0x80) . chr(($num&0x3F) + 0x80);
+            return chr(($num >> 12) + 0xE0) . chr((($num >> 6) & 0x3F) + 0x80) . chr(($num & 0x3F) + 0x80);
         }
         if ($num <= 0x1FFFFF) {
-            return chr(($num>>18) + 0xF0) . chr((($num>>12)&0x3F) + 0x80)
-                 . chr((($num>>6)&0x3F) + 0x80) . chr(($num&0x3F) + 0x80);
+            return chr(($num >> 18) + 0xF0) . chr((($num >> 12) & 0x3F) + 0x80)
+                 . chr((($num >> 6) & 0x3F) + 0x80) . chr(($num & 0x3F) + 0x80);
         }
         throw new Error('Invalid UTF-8 codepoint escape sequence: Codepoint too large');
     }
 
-    public function getType() : string {
+    public function getType(): string {
         return 'Scalar_String';
     }
 }

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

@@ -2,6 +2,5 @@
 
 namespace PhpParser\Node;
 
-abstract class Scalar extends Expr
-{
+abstract class Scalar extends Expr {
 }

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

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

package/plugins/nikic/php-parser/lib/PhpParser/Node/Stmt/Block.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\Stmt;
+
+class Block extends Stmt {
+    /** @var Stmt[] Statements */
+    public array $stmts;
+
+    /**
+     * A block of statements.
+     *
+     * @param Stmt[] $stmts Statements
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(array $stmts, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->stmts = $stmts;
+    }
+
+    public function getType(): string {
+        return 'Stmt_Block';
+    }
+
+    public function getSubNodeNames(): array {
+        return ['stmts'];
+    }
+}

package/plugins/nikic/php-parser/lib/PhpParser/Node/Stmt/Break_.php

@@ -4,27 +4,26 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-class Break_ extends Node\Stmt
-{
+class Break_ extends Node\Stmt {
     /** @var null|Node\Expr Number of loops to break */
-    public $num;
+    public ?Node\Expr $num;
 
     /**
      * Constructs a break node.
      *
-     * @param null|Node\Expr $num        Number of loops to break
-     * @param array          $attributes Additional attributes
+     * @param null|Node\Expr $num Number of loops to break
+     * @param array<string, mixed> $attributes Additional attributes
      */
-    public function __construct(Node\Expr $num = null, array $attributes = []) {
+    public function __construct(?Node\Expr $num = null, array $attributes = []) {
         $this->attributes = $attributes;
         $this->num = $num;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['num'];
     }
-    
-    public function getType() : string {
+
+    public function getType(): string {
         return 'Stmt_Break';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Stmt/Case_.php

@@ -4,31 +4,30 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-class Case_ extends Node\Stmt
-{
+class Case_ extends Node\Stmt {
     /** @var null|Node\Expr Condition (null for default) */
-    public $cond;
+    public ?Node\Expr $cond;
     /** @var Node\Stmt[] Statements */
-    public $stmts;
+    public array $stmts;
 
     /**
      * Constructs a case node.
      *
-     * @param null|Node\Expr $cond       Condition (null for default)
-     * @param Node\Stmt[]    $stmts      Statements
-     * @param array          $attributes Additional attributes
+     * @param null|Node\Expr $cond Condition (null for default)
+     * @param Node\Stmt[] $stmts Statements
+     * @param array<string, mixed> $attributes Additional attributes
      */
-    public function __construct($cond, array $stmts = [], array $attributes = []) {
+    public function __construct(?Node\Expr $cond, array $stmts = [], array $attributes = []) {
         $this->attributes = $attributes;
         $this->cond = $cond;
         $this->stmts = $stmts;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['cond', 'stmts'];
     }
-    
-    public function getType() : string {
+
+    public function getType(): string {
         return 'Stmt_Case';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Stmt/Catch_.php

@@ -5,25 +5,24 @@ namespace PhpParser\Node\Stmt;
 use PhpParser\Node;
 use PhpParser\Node\Expr;
 
-class Catch_ extends Node\Stmt
-{
+class Catch_ extends Node\Stmt {
     /** @var Node\Name[] Types of exceptions to catch */
-    public $types;
+    public array $types;
     /** @var Expr\Variable|null Variable for exception */
-    public $var;
+    public ?Expr\Variable $var;
     /** @var Node\Stmt[] Statements */
-    public $stmts;
+    public array $stmts;
 
     /**
      * Constructs a catch node.
      *
-     * @param Node\Name[]           $types      Types of exceptions to catch
-     * @param Expr\Variable|null    $var        Variable for exception
-     * @param Node\Stmt[]           $stmts      Statements
-     * @param array                 $attributes Additional attributes
+     * @param Node\Name[] $types Types of exceptions to catch
+     * @param Expr\Variable|null $var Variable for exception
+     * @param Node\Stmt[] $stmts Statements
+     * @param array<string, mixed> $attributes Additional attributes
      */
     public function __construct(
-        array $types, Expr\Variable $var = null, array $stmts = [], array $attributes = []
+        array $types, ?Expr\Variable $var = null, array $stmts = [], array $attributes = []
     ) {
         $this->attributes = $attributes;
         $this->types = $types;
@@ -31,11 +30,11 @@ class Catch_ extends Node\Stmt
         $this->stmts = $stmts;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['types', 'var', 'stmts'];
     }
 
-    public function getType() : string {
+    public function getType(): string {
         return 'Stmt_Catch';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassConst.php

@@ -2,84 +2,76 @@
 
 namespace PhpParser\Node\Stmt;
 
+use PhpParser\Modifiers;
 use PhpParser\Node;
 
-class ClassConst extends Node\Stmt
-{
+class ClassConst extends Node\Stmt {
     /** @var int Modifiers */
-    public $flags;
+    public int $flags;
     /** @var Node\Const_[] Constant declarations */
-    public $consts;
+    public array $consts;
     /** @var Node\AttributeGroup[] PHP attribute groups */
-    public $attrGroups;
+    public array $attrGroups;
     /** @var Node\Identifier|Node\Name|Node\ComplexType|null Type declaration */
-    public $type;
+    public ?Node $type;
 
     /**
      * Constructs a class const list node.
      *
-     * @param Node\Const_[]                                          $consts     Constant declarations
-     * @param int                                                    $flags      Modifiers
-     * @param array                                                  $attributes Additional attributes
-     * @param Node\AttributeGroup[]                                  $attrGroups PHP attribute groups
-     * @param null|string|Node\Identifier|Node\Name|Node\ComplexType $type       Type declaration
+     * @param Node\Const_[] $consts Constant declarations
+     * @param int $flags Modifiers
+     * @param array<string, mixed> $attributes Additional attributes
+     * @param list<Node\AttributeGroup> $attrGroups PHP attribute groups
+     * @param null|Node\Identifier|Node\Name|Node\ComplexType $type Type declaration
      */
     public function __construct(
         array $consts,
         int $flags = 0,
         array $attributes = [],
         array $attrGroups = [],
-        $type = null
+        ?Node $type = null
     ) {
         $this->attributes = $attributes;
         $this->flags = $flags;
         $this->consts = $consts;
         $this->attrGroups = $attrGroups;
-        $this->type = \is_string($type) ? new Node\Identifier($type) : $type;
+        $this->type = $type;
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['attrGroups', 'flags', 'type', 'consts'];
     }
 
     /**
      * Whether constant is explicitly or implicitly public.
-     *
-     * @return bool
      */
-    public function isPublic() : bool {
-        return ($this->flags & Class_::MODIFIER_PUBLIC) !== 0
-            || ($this->flags & Class_::VISIBILITY_MODIFIER_MASK) === 0;
+    public function isPublic(): bool {
+        return ($this->flags & Modifiers::PUBLIC) !== 0
+            || ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
     }
 
     /**
      * Whether constant is protected.
-     *
-     * @return bool
      */
-    public function isProtected() : bool {
-        return (bool) ($this->flags & Class_::MODIFIER_PROTECTED);
+    public function isProtected(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED);
     }
 
     /**
      * Whether constant is private.
-     *
-     * @return bool
      */
-    public function isPrivate() : bool {
-        return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
+    public function isPrivate(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE);
     }
 
     /**
      * Whether constant is final.
-     *
-     * @return bool
      */
-    public function isFinal() : bool {
-        return (bool) ($this->flags & Class_::MODIFIER_FINAL);
+    public function isFinal(): bool {
+        return (bool) ($this->flags & Modifiers::FINAL);
     }
 
-    public function getType() : string {
+    public function getType(): string {
         return 'Stmt_ClassConst';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassLike.php

@@ -3,23 +3,23 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
+use PhpParser\Node\PropertyItem;
 
-abstract class ClassLike extends Node\Stmt
-{
+abstract class ClassLike extends Node\Stmt {
     /** @var Node\Identifier|null Name */
-    public $name;
+    public ?Node\Identifier $name;
     /** @var Node\Stmt[] Statements */
-    public $stmts;
+    public array $stmts;
     /** @var Node\AttributeGroup[] PHP attribute groups */
-    public $attrGroups;
+    public array $attrGroups;
 
     /** @var Node\Name|null Namespaced name (if using NameResolver) */
-    public $namespacedName;
+    public ?Node\Name $namespacedName;
 
     /**
-     * @return TraitUse[]
+     * @return list<TraitUse>
      */
-    public function getTraitUses() : array {
+    public function getTraitUses(): array {
         $traitUses = [];
         foreach ($this->stmts as $stmt) {
             if ($stmt instanceof TraitUse) {
@@ -30,9 +30,9 @@ abstract class ClassLike extends Node\Stmt
     }
 
     /**
-     * @return ClassConst[]
+     * @return list<ClassConst>
      */
-    public function getConstants() : array {
+    public function getConstants(): array {
         $constants = [];
         foreach ($this->stmts as $stmt) {
             if ($stmt instanceof ClassConst) {
@@ -43,9 +43,9 @@ abstract class ClassLike extends Node\Stmt
     }
 
     /**
-     * @return Property[]
+     * @return list<Property>
      */
-    public function getProperties() : array {
+    public function getProperties(): array {
         $properties = [];
         foreach ($this->stmts as $stmt) {
             if ($stmt instanceof Property) {
@@ -62,11 +62,11 @@ abstract class ClassLike extends Node\Stmt
      *
      * @return Property|null Property node or null if the property does not exist
      */
-    public function getProperty(string $name) {
+    public function getProperty(string $name): ?Property {
         foreach ($this->stmts as $stmt) {
             if ($stmt instanceof Property) {
                 foreach ($stmt->props as $prop) {
-                    if ($prop instanceof PropertyProperty && $name === $prop->name->toString()) {
+                    if ($prop instanceof PropertyItem && $name === $prop->name->toString()) {
                         return $stmt;
                     }
                 }
@@ -78,9 +78,9 @@ abstract class ClassLike extends Node\Stmt
     /**
      * Gets all methods defined directly in this class/interface/trait
      *
-     * @return ClassMethod[]
+     * @return list<ClassMethod>
      */
-    public function getMethods() : array {
+    public function getMethods(): array {
         $methods = [];
         foreach ($this->stmts as $stmt) {
             if ($stmt instanceof ClassMethod) {
@@ -97,7 +97,7 @@ abstract class ClassLike extends Node\Stmt
      *
      * @return ClassMethod|null Method node or null if the method does not exist
      */
-    public function getMethod(string $name) {
+    public function getMethod(string $name): ?ClassMethod {
         $lowerName = strtolower($name);
         foreach ($this->stmts as $stmt) {
             if ($stmt instanceof ClassMethod && $lowerName === $stmt->name->toLowerString()) {