@appthreat/atom 1.8.1 → 1.8.2

package/plugins/nikic/php-parser/lib/PhpParser/NameContext.php

@@ -6,18 +6,19 @@ use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt;
 
-class NameContext {
+class NameContext
+{
     /** @var null|Name Current namespace */
-    protected ?Name $namespace;
+    protected $namespace;
 
     /** @var Name[][] Map of format [aliasType => [aliasName => originalName]] */
-    protected array $aliases = [];
+    protected $aliases = [];
 
     /** @var Name[][] Same as $aliases but preserving original case */
-    protected array $origAliases = [];
+    protected $origAliases = [];
 
     /** @var ErrorHandler Error handler */
-    protected ErrorHandler $errorHandler;
+    protected $errorHandler;
 
     /**
      * Create a name context.
@@ -35,7 +36,7 @@ class NameContext {
      *
      * @param Name|null $namespace Null is the global namespace
      */
-    public function startNamespace(?Name $namespace = null): void {
+    public function startNamespace(Name $namespace = null) {
         $this->namespace = $namespace;
         $this->origAliases = $this->aliases = [
             Stmt\Use_::TYPE_NORMAL   => [],
@@ -47,12 +48,12 @@ class NameContext {
     /**
      * Add an alias / import.
      *
-     * @param Name $name Original name
-     * @param string $aliasName Aliased name
-     * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
-     * @param array<string, mixed> $errorAttrs Attributes to use to report an error
+     * @param Name   $name        Original name
+     * @param string $aliasName   Aliased name
+     * @param int    $type        One of Stmt\Use_::TYPE_*
+     * @param array  $errorAttrs Attributes to use to report an error
      */
-    public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []): void {
+    public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []) {
         // Constant names are case sensitive, everything else case insensitive
         if ($type === Stmt\Use_::TYPE_CONSTANT) {
             $aliasLookupName = $aliasName;
@@ -86,7 +87,7 @@ class NameContext {
      *
      * @return null|Name Namespace (or null if global namespace)
      */
-    public function getNamespace(): ?Name {
+    public function getNamespace() {
         return $this->namespace;
     }
 
@@ -94,11 +95,11 @@ class NameContext {
      * Get resolved name.
      *
      * @param Name $name Name to resolve
-     * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_{FUNCTION|CONSTANT}
+     * @param int  $type One of Stmt\Use_::TYPE_{FUNCTION|CONSTANT}
      *
      * @return null|Name Resolved name, or null if static resolution is not possible
      */
-    public function getResolvedName(Name $name, int $type): ?Name {
+    public function getResolvedName(Name $name, int $type) {
         // don't resolve special class names
         if ($type === Stmt\Use_::TYPE_NORMAL && $name->isSpecialClassName()) {
             if (!$name->isUnqualified()) {
@@ -141,7 +142,7 @@ class NameContext {
      *
      * @return Name Resolved name
      */
-    public function getResolvedClassName(Name $name): Name {
+    public function getResolvedClassName(Name $name) : Name {
         return $this->getResolvedName($name, Stmt\Use_::TYPE_NORMAL);
     }
 
@@ -149,11 +150,11 @@ class NameContext {
      * Get possible ways of writing a fully qualified name (e.g., by making use of aliases).
      *
      * @param string $name Fully-qualified name (without leading namespace separator)
-     * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+     * @param int    $type One of Stmt\Use_::TYPE_*
      *
      * @return Name[] Possible representations of the name
      */
-    public function getPossibleNames(string $name, int $type): array {
+    public function getPossibleNames(string $name, int $type) : array {
         $lcName = strtolower($name);
 
         if ($type === Stmt\Use_::TYPE_NORMAL) {
@@ -205,11 +206,11 @@ class NameContext {
      * Get shortest representation of this fully-qualified name.
      *
      * @param string $name Fully-qualified name (without leading namespace separator)
-     * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+     * @param int    $type One of Stmt\Use_::TYPE_*
      *
      * @return Name Shortest representation
      */
-    public function getShortName(string $name, int $type): Name {
+    public function getShortName(string $name, int $type) : Name {
         $possibleNames = $this->getPossibleNames($name, $type);
 
         // Find shortest name
@@ -223,10 +224,10 @@ class NameContext {
             }
         }
 
-        return $shortestName;
+       return $shortestName;
     }
 
-    private function resolveAlias(Name $name, int $type): ?FullyQualified {
+    private function resolveAlias(Name $name, $type) {
         $firstPart = $name->getFirst();
 
         if ($name->isQualified()) {
@@ -249,7 +250,7 @@ class NameContext {
         return null;
     }
 
-    private function getNamespaceRelativeName(string $name, string $lcName, int $type): ?Name {
+    private function getNamespaceRelativeName(string $name, string $lcName, int $type) {
         if (null === $this->namespace) {
             return new Name($name);
         }
@@ -270,7 +271,7 @@ class NameContext {
         return null;
     }
 
-    private function normalizeConstName(string $name): string {
+    private function normalizeConstName(string $name) {
         $nsSep = strrpos($name, '\\');
         if (false === $nsSep) {
             return $name;

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

@@ -2,30 +2,32 @@
 
 namespace PhpParser\Node;
 
+use PhpParser\Node\VariadicPlaceholder;
 use PhpParser\NodeAbstract;
 
-class Arg extends NodeAbstract {
+class Arg extends NodeAbstract
+{
     /** @var Identifier|null Parameter name (for named parameters) */
-    public ?Identifier $name;
+    public $name;
     /** @var Expr Value to pass */
-    public Expr $value;
+    public $value;
     /** @var bool Whether to pass by ref */
-    public bool $byRef;
+    public $byRef;
     /** @var bool Whether to unpack the argument */
-    public bool $unpack;
+    public $unpack;
 
     /**
      * Constructs a function call argument node.
      *
-     * @param Expr $value Value to pass
-     * @param bool $byRef Whether to pass by ref
-     * @param bool $unpack Whether to unpack the argument
-     * @param array<string, mixed> $attributes Additional attributes
+     * @param Expr  $value      Value to pass
+     * @param bool  $byRef      Whether to pass by ref
+     * @param bool  $unpack     Whether to unpack the argument
+     * @param array $attributes Additional attributes
      * @param Identifier|null $name Parameter name (for named parameters)
      */
     public function __construct(
         Expr $value, bool $byRef = false, bool $unpack = false, array $attributes = [],
-        ?Identifier $name = null
+        Identifier $name = null
     ) {
         $this->attributes = $attributes;
         $this->name = $name;
@@ -34,11 +36,11 @@ class Arg extends NodeAbstract {
         $this->unpack = $unpack;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['name', 'value', 'byRef', 'unpack'];
     }
-
-    public function getType(): string {
+    
+    public function getType() : string {
         return 'Arg';
     }
 }

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

@@ -5,17 +5,18 @@ namespace PhpParser\Node;
 use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class Attribute extends NodeAbstract {
+class Attribute extends NodeAbstract
+{
     /** @var Name Attribute name */
-    public Name $name;
+    public $name;
 
-    /** @var list<Arg> Attribute arguments */
-    public array $args;
+    /** @var Arg[] Attribute arguments */
+    public $args;
 
     /**
-     * @param Node\Name $name Attribute name
-     * @param list<Arg> $args Attribute arguments
-     * @param array<string, mixed> $attributes Additional node attributes
+     * @param Node\Name $name       Attribute name
+     * @param Arg[]     $args       Attribute arguments
+     * @param array     $attributes Additional node attributes
      */
     public function __construct(Name $name, array $args = [], array $attributes = []) {
         $this->attributes = $attributes;
@@ -23,11 +24,11 @@ class Attribute extends NodeAbstract {
         $this->args = $args;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['name', 'args'];
     }
 
-    public function getType(): string {
+    public function getType() : string {
         return 'Attribute';
     }
 }

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

@@ -2,26 +2,28 @@
 
 namespace PhpParser\Node;
 
+use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class AttributeGroup extends NodeAbstract {
+class AttributeGroup extends NodeAbstract
+{
     /** @var Attribute[] Attributes */
-    public array $attrs;
+    public $attrs;
 
     /**
      * @param Attribute[] $attrs PHP attributes
-     * @param array<string, mixed> $attributes Additional node attributes
+     * @param array $attributes Additional node attributes
      */
     public function __construct(array $attrs, array $attributes = []) {
         $this->attributes = $attributes;
         $this->attrs = $attrs;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['attrs'];
     }
 
-    public function getType(): string {
+    public function getType() : string {
         return 'AttributeGroup';
     }
 }

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

@@ -9,5 +9,6 @@ use PhpParser\NodeAbstract;
  *
  * It does not provide any shared behavior and exists only for type-checking purposes.
  */
-abstract class ComplexType extends NodeAbstract {
+abstract class ComplexType extends NodeAbstract
+{
 }

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

@@ -4,21 +4,22 @@ namespace PhpParser\Node;
 
 use PhpParser\NodeAbstract;
 
-class Const_ extends NodeAbstract {
+class Const_ extends NodeAbstract
+{
     /** @var Identifier Name */
-    public Identifier $name;
+    public $name;
     /** @var Expr Value */
-    public Expr $value;
+    public $value;
 
     /** @var Name|null Namespaced name (if using NameResolver) */
-    public ?Name $namespacedName;
+    public $namespacedName;
 
     /**
      * Constructs a const node for use in class const and const statements.
      *
-     * @param string|Identifier $name Name
-     * @param Expr $value Value
-     * @param array<string, mixed> $attributes Additional attributes
+     * @param string|Identifier $name       Name
+     * @param Expr              $value      Value
+     * @param array             $attributes Additional attributes
      */
     public function __construct($name, Expr $value, array $attributes = []) {
         $this->attributes = $attributes;
@@ -26,11 +27,11 @@ class Const_ extends NodeAbstract {
         $this->value = $value;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['name', 'value'];
     }
 
-    public function getType(): string {
+    public function getType() : string {
         return 'Const';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayDimFetch.php

@@ -4,30 +4,31 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-class ArrayDimFetch extends Expr {
+class ArrayDimFetch extends Expr
+{
     /** @var Expr Variable */
-    public Expr $var;
+    public $var;
     /** @var null|Expr Array index / dim */
-    public ?Expr $dim;
+    public $dim;
 
     /**
      * Constructs an array index fetch node.
      *
-     * @param Expr $var Variable
-     * @param null|Expr $dim Array index / dim
-     * @param array<string, mixed> $attributes Additional attributes
+     * @param Expr      $var        Variable
+     * @param null|Expr $dim        Array index / dim
+     * @param array     $attributes Additional attributes
      */
-    public function __construct(Expr $var, ?Expr $dim = null, array $attributes = []) {
+    public function __construct(Expr $var, Expr $dim = null, array $attributes = []) {
         $this->attributes = $attributes;
         $this->var = $var;
         $this->dim = $dim;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['var', 'dim'];
     }
-
-    public function getType(): string {
+    
+    public function getType() : string {
         return 'Expr_ArrayDimFetch';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayItem.php

@@ -1,3 +1,41 @@
 <?php declare(strict_types=1);
 
-require __DIR__ . '/../ArrayItem.php';
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+
+class ArrayItem extends Expr
+{
+    /** @var null|Expr Key */
+    public $key;
+    /** @var Expr Value */
+    public $value;
+    /** @var bool Whether to assign by reference */
+    public $byRef;
+    /** @var bool Whether to unpack the argument */
+    public $unpack;
+
+    /**
+     * Constructs an array item node.
+     *
+     * @param Expr      $value      Value
+     * @param null|Expr $key        Key
+     * @param bool      $byRef      Whether to assign by reference
+     * @param array     $attributes Additional attributes
+     */
+    public function __construct(Expr $value, Expr $key = null, bool $byRef = false, array $attributes = [], bool $unpack = false) {
+        $this->attributes = $attributes;
+        $this->key = $key;
+        $this->value = $value;
+        $this->byRef = $byRef;
+        $this->unpack = $unpack;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['key', 'value', 'byRef', 'unpack'];
+    }
+
+    public function getType() : string {
+        return 'Expr_ArrayItem';
+    }
+}

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/Array_.php

@@ -2,33 +2,33 @@
 
 namespace PhpParser\Node\Expr;
 
-use PhpParser\Node\ArrayItem;
 use PhpParser\Node\Expr;
 
-class Array_ extends Expr {
+class Array_ extends Expr
+{
     // For use in "kind" attribute
-    public const KIND_LONG = 1;  // array() syntax
-    public const KIND_SHORT = 2; // [] syntax
+    const KIND_LONG = 1;  // array() syntax
+    const KIND_SHORT = 2; // [] syntax
 
-    /** @var ArrayItem[] Items */
-    public array $items;
+    /** @var (ArrayItem|null)[] Items */
+    public $items;
 
     /**
      * Constructs an array node.
      *
-     * @param ArrayItem[] $items Items of the array
-     * @param array<string, mixed> $attributes Additional attributes
+     * @param (ArrayItem|null)[] $items      Items of the array
+     * @param array       $attributes Additional attributes
      */
     public function __construct(array $items = [], array $attributes = []) {
         $this->attributes = $attributes;
         $this->items = $items;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['items'];
     }
-
-    public function getType(): string {
+    
+    public function getType() : string {
         return 'Expr_Array';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/ArrowFunction.php

@@ -6,60 +6,55 @@ use PhpParser\Node;
 use PhpParser\Node\Expr;
 use PhpParser\Node\FunctionLike;
 
-class ArrowFunction extends Expr implements FunctionLike {
-    /** @var bool Whether the closure is static */
-    public bool $static;
+class ArrowFunction extends Expr implements FunctionLike
+{
+    /** @var bool */
+    public $static;
 
-    /** @var bool Whether to return by reference */
-    public bool $byRef;
+    /** @var bool */
+    public $byRef;
 
     /** @var Node\Param[] */
-    public array $params = [];
+    public $params = [];
 
     /** @var null|Node\Identifier|Node\Name|Node\ComplexType */
-    public ?Node $returnType;
+    public $returnType;
 
-    /** @var Expr Expression body */
-    public Expr $expr;
+    /** @var Expr */
+    public $expr;
     /** @var Node\AttributeGroup[] */
-    public array $attrGroups;
+    public $attrGroups;
 
     /**
-     * @param array{
-     *     expr: Expr,
-     *     static?: bool,
-     *     byRef?: bool,
-     *     params?: Node\Param[],
-     *     returnType?: null|Node\Identifier|Node\Name|Node\ComplexType,
-     *     attrGroups?: Node\AttributeGroup[]
-     * } $subNodes Array of the following subnodes:
-     *             'expr'                  : Expression body
-     *             'static'     => false   : Whether the closure is static
-     *             'byRef'      => false   : Whether to return by reference
-     *             'params'     => array() : Parameters
-     *             'returnType' => null    : Return type
-     *             'attrGroups' => array() : PHP attribute groups
-     * @param array<string, mixed> $attributes Additional attributes
+     * @param array $subNodes   Array of the following optional subnodes:
+     *                          'static'     => false   : Whether the closure is static
+     *                          'byRef'      => false   : Whether to return by reference
+     *                          'params'     => array() : Parameters
+     *                          'returnType' => null    : Return type
+     *                          'expr'       => Expr    : Expression body
+     *                          'attrGroups' => array() : PHP attribute groups
+     * @param array $attributes Additional attributes
      */
-    public function __construct(array $subNodes, array $attributes = []) {
+    public function __construct(array $subNodes = [], array $attributes = []) {
         $this->attributes = $attributes;
         $this->static = $subNodes['static'] ?? false;
         $this->byRef = $subNodes['byRef'] ?? false;
         $this->params = $subNodes['params'] ?? [];
-        $this->returnType = $subNodes['returnType'] ?? null;
+        $returnType = $subNodes['returnType'] ?? null;
+        $this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
         $this->expr = $subNodes['expr'];
         $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['attrGroups', 'static', 'byRef', 'params', 'returnType', 'expr'];
     }
 
-    public function returnsByRef(): bool {
+    public function returnsByRef() : bool {
         return $this->byRef;
     }
 
-    public function getParams(): array {
+    public function getParams() : array {
         return $this->params;
     }
 
@@ -67,18 +62,18 @@ class ArrowFunction extends Expr implements FunctionLike {
         return $this->returnType;
     }
 
-    public function getAttrGroups(): array {
+    public function getAttrGroups() : array {
         return $this->attrGroups;
     }
 
     /**
      * @return Node\Stmt\Return_[]
      */
-    public function getStmts(): array {
+    public function getStmts() : array {
         return [new Node\Stmt\Return_($this->expr)];
     }
 
-    public function getType(): string {
+    public function getType() : string {
         return 'Expr_ArrowFunction';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/Assign.php

@@ -4,18 +4,19 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-class Assign extends Expr {
+class Assign extends Expr
+{
     /** @var Expr Variable */
-    public Expr $var;
+    public $var;
     /** @var Expr Expression */
-    public Expr $expr;
+    public $expr;
 
     /**
      * Constructs an assignment node.
      *
-     * @param Expr $var Variable
-     * @param Expr $expr Expression
-     * @param array<string, mixed> $attributes Additional attributes
+     * @param Expr  $var        Variable
+     * @param Expr  $expr       Expression
+     * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, Expr $expr, array $attributes = []) {
         $this->attributes = $attributes;
@@ -23,11 +24,11 @@ class Assign extends Expr {
         $this->expr = $expr;
     }
 
-    public function getSubNodeNames(): array {
+    public function getSubNodeNames() : array {
         return ['var', 'expr'];
     }
-
-    public function getType(): string {
+    
+    public function getType() : string {
         return 'Expr_Assign';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseAnd.php

@@ -4,8 +4,9 @@ namespace PhpParser\Node\Expr\AssignOp;
 
 use PhpParser\Node\Expr\AssignOp;
 
-class BitwiseAnd extends AssignOp {
-    public function getType(): string {
+class BitwiseAnd extends AssignOp
+{
+    public function getType() : string {
         return 'Expr_AssignOp_BitwiseAnd';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseOr.php

@@ -4,8 +4,9 @@ namespace PhpParser\Node\Expr\AssignOp;
 
 use PhpParser\Node\Expr\AssignOp;
 
-class BitwiseOr extends AssignOp {
-    public function getType(): string {
+class BitwiseOr extends AssignOp
+{
+    public function getType() : string {
         return 'Expr_AssignOp_BitwiseOr';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseXor.php

@@ -4,8 +4,9 @@ namespace PhpParser\Node\Expr\AssignOp;
 
 use PhpParser\Node\Expr\AssignOp;
 
-class BitwiseXor extends AssignOp {
-    public function getType(): string {
+class BitwiseXor extends AssignOp
+{
+    public function getType() : string {
         return 'Expr_AssignOp_BitwiseXor';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Coalesce.php

@@ -4,8 +4,9 @@ namespace PhpParser\Node\Expr\AssignOp;
 
 use PhpParser\Node\Expr\AssignOp;
 
-class Coalesce extends AssignOp {
-    public function getType(): string {
+class Coalesce extends AssignOp
+{
+    public function getType() : string {
         return 'Expr_AssignOp_Coalesce';
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Concat.php

@@ -4,8 +4,9 @@ namespace PhpParser\Node\Expr\AssignOp;
 
 use PhpParser\Node\Expr\AssignOp;
 
-class Concat extends AssignOp {
-    public function getType(): string {
+class Concat extends AssignOp
+{
+    public function getType() : string {
         return 'Expr_AssignOp_Concat';
     }
 }