@appthreat/atom 1.7.5 → 1.8.1

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Class_ extends MagicConst {
+    public function getName(): string {
+        return '__CLASS__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Class';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Dir extends MagicConst {
+    public function getName(): string {
+        return '__DIR__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Dir';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class File extends MagicConst {
+    public function getName(): string {
+        return '__FILE__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_File';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Function_ extends MagicConst {
+    public function getName(): string {
+        return '__FUNCTION__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Function';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Line extends MagicConst {
+    public function getName(): string {
+        return '__LINE__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Line';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Method extends MagicConst {
+    public function getName(): string {
+        return '__METHOD__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Method';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Namespace_ extends MagicConst {
+    public function getName(): string {
+        return '__NAMESPACE__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Namespace';
+    }
+}

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

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar\MagicConst;
+
+use PhpParser\Node\Scalar\MagicConst;
+
+class Trait_ extends MagicConst {
+    public function getName(): string {
+        return '__TRAIT__';
+    }
+
+    public function getType(): string {
+        return 'Scalar_MagicConst_Trait';
+    }
+}

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

@@ -0,0 +1,27 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+use PhpParser\Node\Scalar;
+
+abstract class MagicConst extends Scalar {
+    /**
+     * Constructs a magic constant node.
+     *
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(array $attributes = []) {
+        $this->attributes = $attributes;
+    }
+
+    public function getSubNodeNames(): array {
+        return [];
+    }
+
+    /**
+     * Get name of magic constant.
+     *
+     * @return string Name of magic constant
+     */
+    abstract public function getName(): string;
+}

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

@@ -0,0 +1,161 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+use PhpParser\Error;
+use PhpParser\Node\Scalar;
+
+class String_ extends Scalar {
+    /* For use in "kind" attribute */
+    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 string $value;
+
+    /** @var array<string, string> Escaped character to its decoded value */
+    protected static array $replacements = [
+        '\\' => '\\',
+        '$'  =>  '$',
+        'n'  => "\n",
+        'r'  => "\r",
+        't'  => "\t",
+        'f'  => "\f",
+        'v'  => "\v",
+        'e'  => "\x1B",
+    ];
+
+    /**
+     * Constructs a string scalar node.
+     *
+     * @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 {
+        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 {
+        $attributes['kind'] = ($str[0] === "'" || ($str[1] === "'" && ($str[0] === 'b' || $str[0] === 'B')))
+            ? Scalar\String_::KIND_SINGLE_QUOTED
+            : Scalar\String_::KIND_DOUBLE_QUOTED;
+
+        $attributes['rawValue'] = $str;
+
+        $string = self::parse($str, $parseUnicodeEscape);
+
+        return new self($string, $attributes);
+    }
+
+    /**
+     * @internal
+     *
+     * Parses a string token.
+     *
+     * @param string $str String token content
+     * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
+     *
+     * @return string The parsed string
+     */
+    public static function parse(string $str, bool $parseUnicodeEscape = true): string {
+        $bLength = 0;
+        if ('b' === $str[0] || 'B' === $str[0]) {
+            $bLength = 1;
+        }
+
+        if ('\'' === $str[$bLength]) {
+            return str_replace(
+                ['\\\\', '\\\''],
+                ['\\', '\''],
+                substr($str, $bLength + 1, -1)
+            );
+        } else {
+            return self::parseEscapeSequences(
+                substr($str, $bLength + 1, -1), '"', $parseUnicodeEscape
+            );
+        }
+    }
+
+    /**
+     * @internal
+     *
+     * Parses escape sequences in strings (all string types apart from single quoted).
+     *
+     * @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, ?string $quote, bool $parseUnicodeEscape = true): string {
+        if (null !== $quote) {
+            $str = str_replace('\\' . $quote, $quote, $str);
+        }
+
+        $extra = '';
+        if ($parseUnicodeEscape) {
+            $extra = '|u\{([0-9a-fA-F]+)\}';
+        }
+
+        return preg_replace_callback(
+            '~\\\\([\\\\$nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}' . $extra . ')~',
+            function ($matches) {
+                $str = $matches[1];
+
+                if (isset(self::$replacements[$str])) {
+                    return self::$replacements[$str];
+                }
+                if ('x' === $str[0] || 'X' === $str[0]) {
+                    return chr(hexdec(substr($str, 1)));
+                }
+                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));
+                }
+            },
+            $str
+        );
+    }
+
+    /**
+     * Converts a Unicode code point to its UTF-8 encoded representation.
+     *
+     * @param int $num Code point
+     *
+     * @return string UTF-8 representation of code point
+     */
+    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);
+        }
+        if ($num <= 0xFFFF) {
+            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);
+        }
+        throw new Error('Invalid UTF-8 codepoint escape sequence: Codepoint too large');
+    }
+
+    public function getType(): string {
+        return 'Scalar_String';
+    }
+}

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

@@ -0,0 +1,6 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+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

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Break_ extends Node\Stmt {
+    /** @var null|Node\Expr Number of loops to break */
+    public ?Node\Expr $num;
+
+    /**
+     * Constructs a break node.
+     *
+     * @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 = []) {
+        $this->attributes = $attributes;
+        $this->num = $num;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['num'];
+    }
+
+    public function getType(): string {
+        return 'Stmt_Break';
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr;
+
+class Catch_ extends Node\Stmt {
+    /** @var Node\Name[] Types of exceptions to catch */
+    public array $types;
+    /** @var Expr\Variable|null Variable for exception */
+    public ?Expr\Variable $var;
+    /** @var Node\Stmt[] Statements */
+    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<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(
+        array $types, ?Expr\Variable $var = null, array $stmts = [], array $attributes = []
+    ) {
+        $this->attributes = $attributes;
+        $this->types = $types;
+        $this->var = $var;
+        $this->stmts = $stmts;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['types', 'var', 'stmts'];
+    }
+
+    public function getType(): string {
+        return 'Stmt_Catch';
+    }
+}

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

@@ -0,0 +1,77 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Modifiers;
+use PhpParser\Node;
+
+class ClassConst extends Node\Stmt {
+    /** @var int Modifiers */
+    public int $flags;
+    /** @var Node\Const_[] Constant declarations */
+    public array $consts;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public array $attrGroups;
+    /** @var Node\Identifier|Node\Name|Node\ComplexType|null Type declaration */
+    public ?Node $type;
+
+    /**
+     * Constructs a class const list node.
+     *
+     * @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 = [],
+        ?Node $type = null
+    ) {
+        $this->attributes = $attributes;
+        $this->flags = $flags;
+        $this->consts = $consts;
+        $this->attrGroups = $attrGroups;
+        $this->type = $type;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['attrGroups', 'flags', 'type', 'consts'];
+    }
+
+    /**
+     * Whether constant is explicitly or implicitly public.
+     */
+    public function isPublic(): bool {
+        return ($this->flags & Modifiers::PUBLIC) !== 0
+            || ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+    }
+
+    /**
+     * Whether constant is protected.
+     */
+    public function isProtected(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED);
+    }
+
+    /**
+     * Whether constant is private.
+     */
+    public function isPrivate(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE);
+    }
+
+    /**
+     * Whether constant is final.
+     */
+    public function isFinal(): bool {
+        return (bool) ($this->flags & Modifiers::FINAL);
+    }
+
+    public function getType(): string {
+        return 'Stmt_ClassConst';
+    }
+}

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

@@ -0,0 +1,109 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+use PhpParser\Node\PropertyItem;
+
+abstract class ClassLike extends Node\Stmt {
+    /** @var Node\Identifier|null Name */
+    public ?Node\Identifier $name;
+    /** @var Node\Stmt[] Statements */
+    public array $stmts;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public array $attrGroups;
+
+    /** @var Node\Name|null Namespaced name (if using NameResolver) */
+    public ?Node\Name $namespacedName;
+
+    /**
+     * @return TraitUse[]
+     */
+    public function getTraitUses(): array {
+        $traitUses = [];
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof TraitUse) {
+                $traitUses[] = $stmt;
+            }
+        }
+        return $traitUses;
+    }
+
+    /**
+     * @return ClassConst[]
+     */
+    public function getConstants(): array {
+        $constants = [];
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof ClassConst) {
+                $constants[] = $stmt;
+            }
+        }
+        return $constants;
+    }
+
+    /**
+     * @return Property[]
+     */
+    public function getProperties(): array {
+        $properties = [];
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof Property) {
+                $properties[] = $stmt;
+            }
+        }
+        return $properties;
+    }
+
+    /**
+     * Gets property with the given name defined directly in this class/interface/trait.
+     *
+     * @param string $name Name of the property
+     *
+     * @return Property|null Property node or null if the property does not exist
+     */
+    public function getProperty(string $name): ?Property {
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof Property) {
+                foreach ($stmt->props as $prop) {
+                    if ($prop instanceof PropertyItem && $name === $prop->name->toString()) {
+                        return $stmt;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Gets all methods defined directly in this class/interface/trait
+     *
+     * @return ClassMethod[]
+     */
+    public function getMethods(): array {
+        $methods = [];
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof ClassMethod) {
+                $methods[] = $stmt;
+            }
+        }
+        return $methods;
+    }
+
+    /**
+     * Gets method with the given name defined directly in this class/interface/trait.
+     *
+     * @param string $name Name of the method (compared case-insensitively)
+     *
+     * @return ClassMethod|null Method node or null if the method does not exist
+     */
+    public function getMethod(string $name): ?ClassMethod {
+        $lowerName = strtolower($name);
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof ClassMethod && $lowerName === $stmt->name->toLowerString()) {
+                return $stmt;
+            }
+        }
+        return null;
+    }
+}