@appthreat/atom-parsetools 1.0.4 → 1.0.6

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

@@ -0,0 +1,85 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser;
+
+/**
+ * Modifiers used (as a bit mask) by various flags subnodes, for example on classes, functions,
+ * properties and constants.
+ */
+final class Modifiers {
+    public const PUBLIC    =  1;
+    public const PROTECTED =  2;
+    public const PRIVATE   =  4;
+    public const STATIC    =  8;
+    public const ABSTRACT  = 16;
+    public const FINAL     = 32;
+    public const READONLY  = 64;
+    public const PUBLIC_SET = 128;
+    public const PROTECTED_SET = 256;
+    public const PRIVATE_SET = 512;
+
+    public const VISIBILITY_MASK = self::PUBLIC | self::PROTECTED | self::PRIVATE;
+
+    public const VISIBILITY_SET_MASK = self::PUBLIC_SET | self::PROTECTED_SET | self::PRIVATE_SET;
+
+    private const TO_STRING_MAP = [
+        self::PUBLIC  => 'public',
+        self::PROTECTED => 'protected',
+        self::PRIVATE => 'private',
+        self::STATIC  => 'static',
+        self::ABSTRACT => 'abstract',
+        self::FINAL  => 'final',
+        self::READONLY  => 'readonly',
+        self::PUBLIC_SET => 'public(set)',
+        self::PROTECTED_SET => 'protected(set)',
+        self::PRIVATE_SET => 'private(set)',
+    ];
+
+    public static function toString(int $modifier): string {
+        if (!isset(self::TO_STRING_MAP[$modifier])) {
+            throw new \InvalidArgumentException("Unknown modifier $modifier");
+        }
+        return self::TO_STRING_MAP[$modifier];
+    }
+
+    private static function isValidModifier(int $modifier): bool {
+        $isPow2 = ($modifier & ($modifier - 1)) == 0 && $modifier != 0;
+        return $isPow2 && $modifier <= self::PRIVATE_SET;
+    }
+
+    /**
+     * @internal
+     */
+    public static function verifyClassModifier(int $a, int $b): void {
+        assert(self::isValidModifier($b));
+        if (($a & $b) != 0) {
+            throw new Error(
+                'Multiple ' . self::toString($b) . ' modifiers are not allowed');
+        }
+
+        if ($a & 48 && $b & 48) {
+            throw new Error('Cannot use the final modifier on an abstract class');
+        }
+    }
+
+    /**
+     * @internal
+     */
+    public static function verifyModifier(int $a, int $b): void {
+        assert(self::isValidModifier($b));
+        if (($a & Modifiers::VISIBILITY_MASK && $b & Modifiers::VISIBILITY_MASK) ||
+            ($a & Modifiers::VISIBILITY_SET_MASK && $b & Modifiers::VISIBILITY_SET_MASK)
+        ) {
+            throw new Error('Multiple access type modifiers are not allowed');
+        }
+
+        if (($a & $b) != 0) {
+            throw new Error(
+                'Multiple ' . self::toString($b) . ' modifiers are not allowed');
+        }
+
+        if ($a & 48 && $b & 48) {
+            throw new Error('Cannot use the final modifier on an abstract class member');
+        }
+    }
+}

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

@@ -6,19 +6,18 @@ use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt;
 
-class NameContext
-{
+class NameContext {
     /** @var null|Name Current namespace */
-    protected $namespace;
+    protected ?Name $namespace;
 
     /** @var Name[][] Map of format [aliasType => [aliasName => originalName]] */
-    protected $aliases = [];
+    protected array $aliases = [];
 
     /** @var Name[][] Same as $aliases but preserving original case */
-    protected $origAliases = [];
+    protected array $origAliases = [];
 
     /** @var ErrorHandler Error handler */
-    protected $errorHandler;
+    protected ErrorHandler $errorHandler;
 
     /**
      * Create a name context.
@@ -36,7 +35,7 @@ class NameContext
      *
      * @param Name|null $namespace Null is the global namespace
      */
-    public function startNamespace(Name $namespace = null) {
+    public function startNamespace(?Name $namespace = null): void {
         $this->namespace = $namespace;
         $this->origAliases = $this->aliases = [
             Stmt\Use_::TYPE_NORMAL   => [],
@@ -48,12 +47,12 @@ class NameContext
     /**
      * Add an alias / import.
      *
-     * @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
+     * @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
      */
-    public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []) {
+    public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []): void {
         // Constant names are case sensitive, everything else case insensitive
         if ($type === Stmt\Use_::TYPE_CONSTANT) {
             $aliasLookupName = $aliasName;
@@ -87,7 +86,7 @@ class NameContext
      *
      * @return null|Name Namespace (or null if global namespace)
      */
-    public function getNamespace() {
+    public function getNamespace(): ?Name {
         return $this->namespace;
     }
 
@@ -95,11 +94,11 @@ class NameContext
      * Get resolved name.
      *
      * @param Name $name Name to resolve
-     * @param int  $type One of Stmt\Use_::TYPE_{FUNCTION|CONSTANT}
+     * @param Stmt\Use_::TYPE_* $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) {
+    public function getResolvedName(Name $name, int $type): ?Name {
         // don't resolve special class names
         if ($type === Stmt\Use_::TYPE_NORMAL && $name->isSpecialClassName()) {
             if (!$name->isUnqualified()) {
@@ -142,7 +141,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);
     }
 
@@ -150,11 +149,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 int    $type One of Stmt\Use_::TYPE_*
+     * @param Stmt\Use_::TYPE_* $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) {
@@ -186,7 +185,7 @@ class NameContext
         // Check for relevant type-specific use statements
         foreach ($this->origAliases[$type] as $alias => $orig) {
             if ($type === Stmt\Use_::TYPE_CONSTANT) {
-                // Constants are are complicated-sensitive
+                // Constants are complicated-sensitive
                 $normalizedOrig = $this->normalizeConstName($orig->toString());
                 if ($normalizedOrig === $this->normalizeConstName($name)) {
                     $possibleNames[] = new Name($alias);
@@ -206,11 +205,11 @@ class NameContext
      * Get shortest representation of this fully-qualified name.
      *
      * @param string $name Fully-qualified name (without leading namespace separator)
-     * @param int    $type One of Stmt\Use_::TYPE_*
+     * @param Stmt\Use_::TYPE_* $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
@@ -224,10 +223,10 @@ class NameContext
             }
         }
 
-       return $shortestName;
+        return $shortestName;
     }
 
-    private function resolveAlias(Name $name, $type) {
+    private function resolveAlias(Name $name, int $type): ?FullyQualified {
         $firstPart = $name->getFirst();
 
         if ($name->isQualified()) {
@@ -250,7 +249,7 @@ class NameContext
         return null;
     }
 
-    private function getNamespaceRelativeName(string $name, string $lcName, int $type) {
+    private function getNamespaceRelativeName(string $name, string $lcName, int $type): ?Name {
         if (null === $this->namespace) {
             return new Name($name);
         }
@@ -271,7 +270,7 @@ class NameContext
         return null;
     }
 
-    private function normalizeConstName(string $name) {
+    private function normalizeConstName(string $name): string {
         $nsSep = strrpos($name, '\\');
         if (false === $nsSep) {
             return $name;

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

@@ -2,32 +2,30 @@
 
 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 $name;
+    public ?Identifier $name;
     /** @var Expr Value to pass */
-    public $value;
+    public Expr $value;
     /** @var bool Whether to pass by ref */
-    public $byRef;
+    public bool $byRef;
     /** @var bool Whether to unpack the argument */
-    public $unpack;
+    public bool $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 $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<string, mixed> $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;
@@ -36,11 +34,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/ArrayItem.php

@@ -0,0 +1,43 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+class ArrayItem extends NodeAbstract {
+    /** @var null|Expr Key */
+    public ?Expr $key;
+    /** @var Expr Value */
+    public Expr $value;
+    /** @var bool Whether to assign by reference */
+    public bool $byRef;
+    /** @var bool Whether to unpack the argument */
+    public bool $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<string, mixed> $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 'ArrayItem';
+    }
+}
+
+// @deprecated compatibility alias
+class_alias(ArrayItem::class, Expr\ArrayItem::class);

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

@@ -5,18 +5,17 @@ namespace PhpParser\Node;
 use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class Attribute extends NodeAbstract
-{
+class Attribute extends NodeAbstract {
     /** @var Name Attribute name */
-    public $name;
+    public Name $name;
 
-    /** @var Arg[] Attribute arguments */
-    public $args;
+    /** @var list<Arg> Attribute arguments */
+    public array $args;
 
     /**
-     * @param Node\Name $name       Attribute name
-     * @param Arg[]     $args       Attribute arguments
-     * @param array     $attributes Additional node attributes
+     * @param Node\Name $name Attribute name
+     * @param list<Arg> $args Attribute arguments
+     * @param array<string, mixed> $attributes Additional node attributes
      */
     public function __construct(Name $name, array $args = [], array $attributes = []) {
         $this->attributes = $attributes;
@@ -24,11 +23,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,28 +2,26 @@
 
 namespace PhpParser\Node;
 
-use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class AttributeGroup extends NodeAbstract
-{
+class AttributeGroup extends NodeAbstract {
     /** @var Attribute[] Attributes */
-    public $attrs;
+    public array $attrs;
 
     /**
      * @param Attribute[] $attrs PHP attributes
-     * @param array $attributes Additional node attributes
+     * @param array<string, mixed> $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/ClosureUse.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+class ClosureUse extends NodeAbstract {
+    /** @var Expr\Variable Variable to use */
+    public Expr\Variable $var;
+    /** @var bool Whether to use by reference */
+    public bool $byRef;
+
+    /**
+     * Constructs a closure use node.
+     *
+     * @param Expr\Variable $var Variable to use
+     * @param bool $byRef Whether to use by reference
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(Expr\Variable $var, bool $byRef = false, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->var = $var;
+        $this->byRef = $byRef;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['var', 'byRef'];
+    }
+
+    public function getType(): string {
+        return 'ClosureUse';
+    }
+}
+
+// @deprecated compatibility alias
+class_alias(ClosureUse::class, Expr\ClosureUse::class);

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

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

@@ -0,0 +1,37 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class DeclareItem extends NodeAbstract {
+    /** @var Node\Identifier Key */
+    public Identifier $key;
+    /** @var Node\Expr Value */
+    public Expr $value;
+
+    /**
+     * Constructs a declare key=>value pair node.
+     *
+     * @param string|Node\Identifier $key Key
+     * @param Node\Expr $value Value
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct($key, Node\Expr $value, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->key = \is_string($key) ? new Node\Identifier($key) : $key;
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['key', 'value'];
+    }
+
+    public function getType(): string {
+        return 'DeclareItem';
+    }
+}
+
+// @deprecated compatibility alias
+class_alias(DeclareItem::class, Stmt\DeclareDeclare::class);

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

@@ -4,31 +4,30 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-class ArrayDimFetch extends Expr
-{
+class ArrayDimFetch extends Expr {
     /** @var Expr Variable */
-    public $var;
+    public Expr $var;
     /** @var null|Expr Array index / dim */
-    public $dim;
+    public ?Expr $dim;
 
     /**
      * Constructs an array index fetch node.
      *
-     * @param Expr      $var        Variable
-     * @param null|Expr $dim        Array index / dim
-     * @param array     $attributes Additional attributes
+     * @param Expr $var Variable
+     * @param null|Expr $dim Array index / dim
+     * @param array<string, mixed> $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

@@ -2,40 +2,10 @@
 
 namespace PhpParser\Node\Expr;
 
-use PhpParser\Node\Expr;
+require __DIR__ . '/../ArrayItem.php';
 
-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';
+if (false) {
+    // For classmap-authoritative support.
+    class ArrayItem extends \PhpParser\Node\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
-    const KIND_LONG = 1;  // array() syntax
-    const KIND_SHORT = 2; // [] syntax
+    public const KIND_LONG = 1;  // array() syntax
+    public const KIND_SHORT = 2; // [] syntax
 
-    /** @var (ArrayItem|null)[] Items */
-    public $items;
+    /** @var ArrayItem[] Items */
+    public array $items;
 
     /**
      * Constructs an array node.
      *
-     * @param (ArrayItem|null)[] $items      Items of the array
-     * @param array       $attributes Additional attributes
+     * @param ArrayItem[] $items Items of the array
+     * @param array<string, mixed> $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';
     }
 }