@appthreat/atom 1.8.1 → 1.8.2

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

@@ -2,14 +2,14 @@
 
 namespace PhpParser;
 
-abstract class NodeAbstract implements Node, \JsonSerializable {
-    /** @var array<string, mixed> Attributes */
-    protected array $attributes;
+abstract class NodeAbstract implements Node, \JsonSerializable
+{
+    protected $attributes;
 
     /**
      * Creates a Node.
      *
-     * @param array<string, mixed> $attributes Array of attributes
+     * @param array $attributes Array of attributes
      */
     public function __construct(array $attributes = []) {
         $this->attributes = $attributes;
@@ -20,7 +20,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int Start line (or -1 if not available)
      */
-    public function getLine(): int {
+    public function getLine() : int {
         return $this->attributes['startLine'] ?? -1;
     }
 
@@ -31,7 +31,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int Start line (or -1 if not available)
      */
-    public function getStartLine(): int {
+    public function getStartLine() : int {
         return $this->attributes['startLine'] ?? -1;
     }
 
@@ -42,7 +42,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int End line (or -1 if not available)
      */
-    public function getEndLine(): int {
+    public function getEndLine() : int {
         return $this->attributes['endLine'] ?? -1;
     }
 
@@ -55,7 +55,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int Token start position (or -1 if not available)
      */
-    public function getStartTokenPos(): int {
+    public function getStartTokenPos() : int {
         return $this->attributes['startTokenPos'] ?? -1;
     }
 
@@ -68,7 +68,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int Token end position (or -1 if not available)
      */
-    public function getEndTokenPos(): int {
+    public function getEndTokenPos() : int {
         return $this->attributes['endTokenPos'] ?? -1;
     }
 
@@ -79,7 +79,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int File start position (or -1 if not available)
      */
-    public function getStartFilePos(): int {
+    public function getStartFilePos() : int {
         return $this->attributes['startFilePos'] ?? -1;
     }
 
@@ -90,7 +90,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return int File end position (or -1 if not available)
      */
-    public function getEndFilePos(): int {
+    public function getEndFilePos() : int {
         return $this->attributes['endFilePos'] ?? -1;
     }
 
@@ -101,7 +101,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return Comment[]
      */
-    public function getComments(): array {
+    public function getComments() : array {
         return $this->attributes['comments'] ?? [];
     }
 
@@ -110,7 +110,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @return null|Comment\Doc Doc comment object or null
      */
-    public function getDocComment(): ?Comment\Doc {
+    public function getDocComment() {
         $comments = $this->getComments();
         for ($i = count($comments) - 1; $i >= 0; $i--) {
             $comment = $comments[$i];
@@ -129,7 +129,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
      *
      * @param Comment\Doc $docComment Doc comment to set
      */
-    public function setDocComment(Comment\Doc $docComment): void {
+    public function setDocComment(Comment\Doc $docComment) {
         $comments = $this->getComments();
         for ($i = count($comments) - 1; $i >= 0; $i--) {
             if ($comments[$i] instanceof Comment\Doc) {
@@ -145,11 +145,11 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
         $this->setAttribute('comments', $comments);
     }
 
-    public function setAttribute(string $key, $value): void {
+    public function setAttribute(string $key, $value) {
         $this->attributes[$key] = $value;
     }
 
-    public function hasAttribute(string $key): bool {
+    public function hasAttribute(string $key) : bool {
         return array_key_exists($key, $this->attributes);
     }
 
@@ -161,18 +161,18 @@ abstract class NodeAbstract implements Node, \JsonSerializable {
         return $default;
     }
 
-    public function getAttributes(): array {
+    public function getAttributes() : array {
         return $this->attributes;
     }
 
-    public function setAttributes(array $attributes): void {
+    public function setAttributes(array $attributes) {
         $this->attributes = $attributes;
     }
 
     /**
-     * @return array<string, mixed>
+     * @return array
      */
-    public function jsonSerialize(): array {
+    public function jsonSerialize() : array {
         return ['nodeType' => $this->getType()] + get_object_vars($this);
     }
 }

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

@@ -2,33 +2,17 @@
 
 namespace PhpParser;
 
-use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\Include_;
-use PhpParser\Node\Expr\List_;
-use PhpParser\Node\Scalar\Int_;
-use PhpParser\Node\Scalar\InterpolatedString;
-use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\GroupUse;
 use PhpParser\Node\Stmt\Use_;
-use PhpParser\Node\UseItem;
+use PhpParser\Node\Stmt\UseUse;
 
-class NodeDumper {
-    private bool $dumpComments;
-    private bool $dumpPositions;
-    private bool $dumpOtherAttributes;
-    private ?string $code;
-    private string $res;
-    private string $nl;
-
-    private const IGNORE_ATTRIBUTES = [
-        'comments' => true,
-        'startLine' => true,
-        'endLine' => true,
-        'startFilePos' => true,
-        'endFilePos' => true,
-        'startTokenPos' => true,
-        'endTokenPos' => true,
-    ];
+class NodeDumper
+{
+    private $dumpComments;
+    private $dumpPositions;
+    private $code;
 
     /**
      * Constructs a NodeDumper.
@@ -37,218 +21,150 @@ class NodeDumper {
      *  * bool dumpComments: Whether comments should be dumped.
      *  * bool dumpPositions: Whether line/offset information should be dumped. To dump offset
      *                        information, the code needs to be passed to dump().
-     *  * bool dumpOtherAttributes: Whether non-comment, non-position attributes should be dumped.
      *
      * @param array $options Options (see description)
      */
     public function __construct(array $options = []) {
         $this->dumpComments = !empty($options['dumpComments']);
         $this->dumpPositions = !empty($options['dumpPositions']);
-        $this->dumpOtherAttributes = !empty($options['dumpOtherAttributes']);
     }
 
     /**
      * Dumps a node or array.
      *
-     * @param array|Node $node Node or array to dump
+     * @param array|Node  $node Node or array to dump
      * @param string|null $code Code corresponding to dumped AST. This only needs to be passed if
      *                          the dumpPositions option is enabled and the dumping of node offsets
      *                          is desired.
      *
      * @return string Dumped value
      */
-    public function dump($node, ?string $code = null): string {
+    public function dump($node, string $code = null) : string {
         $this->code = $code;
-        $this->res = '';
-        $this->nl = "\n";
-        $this->dumpRecursive($node, false);
-        return $this->res;
+        return $this->dumpRecursive($node);
     }
 
-    /** @param mixed $node */
-    protected function dumpRecursive($node, bool $indent = true): void {
-        if ($indent) {
-            $this->nl .= "    ";
-        }
+    protected function dumpRecursive($node) {
         if ($node instanceof Node) {
-            $this->res .= $node->getType();
+            $r = $node->getType();
             if ($this->dumpPositions && null !== $p = $this->dumpPosition($node)) {
-                $this->res .= $p;
+                $r .= $p;
             }
-            $this->res .= '(';
+            $r .= '(';
 
             foreach ($node->getSubNodeNames() as $key) {
-                $this->res .= "$this->nl    " . $key . ': ';
+                $r .= "\n    " . $key . ': ';
 
                 $value = $node->$key;
-                if (\is_int($value)) {
+                if (null === $value) {
+                    $r .= 'null';
+                } elseif (false === $value) {
+                    $r .= 'false';
+                } elseif (true === $value) {
+                    $r .= 'true';
+                } elseif (is_scalar($value)) {
                     if ('flags' === $key || 'newModifier' === $key) {
-                        $this->res .= $this->dumpFlags($value);
-                        continue;
-                    }
-                    if ('type' === $key && $node instanceof Include_) {
-                        $this->res .= $this->dumpIncludeType($value);
-                        continue;
-                    }
-                    if ('type' === $key
-                            && ($node instanceof Use_ || $node instanceof UseItem || $node instanceof GroupUse)) {
-                        $this->res .= $this->dumpUseType($value);
-                        continue;
+                        $r .= $this->dumpFlags($value);
+                    } elseif ('type' === $key && $node instanceof Include_) {
+                        $r .= $this->dumpIncludeType($value);
+                    } elseif ('type' === $key
+                            && ($node instanceof Use_ || $node instanceof UseUse || $node instanceof GroupUse)) {
+                        $r .= $this->dumpUseType($value);
+                    } else {
+                        $r .= $value;
                     }
+                } else {
+                    $r .= str_replace("\n", "\n    ", $this->dumpRecursive($value));
                 }
-                $this->dumpRecursive($value);
             }
 
             if ($this->dumpComments && $comments = $node->getComments()) {
-                $this->res .= "$this->nl    comments: ";
-                $this->dumpRecursive($comments);
+                $r .= "\n    comments: " . str_replace("\n", "\n    ", $this->dumpRecursive($comments));
             }
+        } elseif (is_array($node)) {
+            $r = 'array(';
 
-            if ($this->dumpOtherAttributes) {
-                foreach ($node->getAttributes() as $key => $value) {
-                    if (isset(self::IGNORE_ATTRIBUTES[$key])) {
-                        continue;
-                    }
-
-                    $this->res .= "$this->nl    $key: ";
-                    if (\is_int($value)) {
-                        if ('kind' === $key) {
-                            if ($node instanceof Int_) {
-                                $this->res .= $this->dumpIntKind($value);
-                                continue;
-                            }
-                            if ($node instanceof String_ || $node instanceof InterpolatedString) {
-                                $this->res .= $this->dumpStringKind($value);
-                                continue;
-                            }
-                            if ($node instanceof Array_) {
-                                $this->res .= $this->dumpArrayKind($value);
-                                continue;
-                            }
-                            if ($node instanceof List_) {
-                                $this->res .= $this->dumpListKind($value);
-                                continue;
-                            }
-                        }
-                    }
-                    $this->dumpRecursive($value);
-                }
-            }
-            $this->res .= "$this->nl)";
-        } elseif (\is_array($node)) {
-            $this->res .= 'array(';
             foreach ($node as $key => $value) {
-                $this->res .= "$this->nl    " . $key . ': ';
-                $this->dumpRecursive($value);
+                $r .= "\n    " . $key . ': ';
+
+                if (null === $value) {
+                    $r .= 'null';
+                } elseif (false === $value) {
+                    $r .= 'false';
+                } elseif (true === $value) {
+                    $r .= 'true';
+                } elseif (is_scalar($value)) {
+                    $r .= $value;
+                } else {
+                    $r .= str_replace("\n", "\n    ", $this->dumpRecursive($value));
+                }
             }
-            $this->res .= "$this->nl)";
         } elseif ($node instanceof Comment) {
-            $this->res .= \str_replace("\n", $this->nl, $node->getReformattedText());
-        } elseif (\is_string($node)) {
-            $this->res .= \str_replace("\n", $this->nl, (string)$node);
-        } elseif (\is_int($node) || \is_float($node)) {
-            $this->res .= $node;
-        } elseif (null === $node) {
-            $this->res .= 'null';
-        } elseif (false === $node) {
-            $this->res .= 'false';
-        } elseif (true === $node) {
-            $this->res .= 'true';
+            return $node->getReformattedText();
         } else {
             throw new \InvalidArgumentException('Can only dump nodes and arrays.');
         }
-        if ($indent) {
-            $this->nl = \substr($this->nl, 0, -4);
-        }
+
+        return $r . "\n)";
     }
 
-    protected function dumpFlags(int $flags): string {
+    protected function dumpFlags($flags) {
         $strs = [];
-        if ($flags & Modifiers::PUBLIC) {
-            $strs[] = 'PUBLIC';
+        if ($flags & Class_::MODIFIER_PUBLIC) {
+            $strs[] = 'MODIFIER_PUBLIC';
         }
-        if ($flags & Modifiers::PROTECTED) {
-            $strs[] = 'PROTECTED';
+        if ($flags & Class_::MODIFIER_PROTECTED) {
+            $strs[] = 'MODIFIER_PROTECTED';
         }
-        if ($flags & Modifiers::PRIVATE) {
-            $strs[] = 'PRIVATE';
+        if ($flags & Class_::MODIFIER_PRIVATE) {
+            $strs[] = 'MODIFIER_PRIVATE';
         }
-        if ($flags & Modifiers::ABSTRACT) {
-            $strs[] = 'ABSTRACT';
+        if ($flags & Class_::MODIFIER_ABSTRACT) {
+            $strs[] = 'MODIFIER_ABSTRACT';
         }
-        if ($flags & Modifiers::STATIC) {
-            $strs[] = 'STATIC';
+        if ($flags & Class_::MODIFIER_STATIC) {
+            $strs[] = 'MODIFIER_STATIC';
         }
-        if ($flags & Modifiers::FINAL) {
-            $strs[] = 'FINAL';
+        if ($flags & Class_::MODIFIER_FINAL) {
+            $strs[] = 'MODIFIER_FINAL';
         }
-        if ($flags & Modifiers::READONLY) {
-            $strs[] = 'READONLY';
+        if ($flags & Class_::MODIFIER_READONLY) {
+            $strs[] = 'MODIFIER_READONLY';
         }
 
         if ($strs) {
             return implode(' | ', $strs) . ' (' . $flags . ')';
         } else {
-            return (string) $flags;
+            return $flags;
         }
     }
 
-    /** @param array<int, string> $map */
-    private function dumpEnum(int $value, array $map): string {
-        if (!isset($map[$value])) {
-            return (string) $value;
-        }
-        return $map[$value] . ' (' . $value . ')';
-    }
-
-    private function dumpIncludeType(int $type): string {
-        return $this->dumpEnum($type, [
+    protected function dumpIncludeType($type) {
+        $map = [
             Include_::TYPE_INCLUDE      => 'TYPE_INCLUDE',
             Include_::TYPE_INCLUDE_ONCE => 'TYPE_INCLUDE_ONCE',
             Include_::TYPE_REQUIRE      => 'TYPE_REQUIRE',
             Include_::TYPE_REQUIRE_ONCE => 'TYPE_REQUIRE_ONCE',
-        ]);
+        ];
+
+        if (!isset($map[$type])) {
+            return $type;
+        }
+        return $map[$type] . ' (' . $type . ')';
     }
 
-    private function dumpUseType(int $type): string {
-        return $this->dumpEnum($type, [
+    protected function dumpUseType($type) {
+        $map = [
             Use_::TYPE_UNKNOWN  => 'TYPE_UNKNOWN',
             Use_::TYPE_NORMAL   => 'TYPE_NORMAL',
             Use_::TYPE_FUNCTION => 'TYPE_FUNCTION',
             Use_::TYPE_CONSTANT => 'TYPE_CONSTANT',
-        ]);
-    }
-
-    private function dumpIntKind(int $kind): string {
-        return $this->dumpEnum($kind, [
-            Int_::KIND_BIN => 'KIND_BIN',
-            Int_::KIND_OCT => 'KIND_OCT',
-            Int_::KIND_DEC => 'KIND_DEC',
-            Int_::KIND_HEX => 'KIND_HEX',
-        ]);
-    }
-
-    private function dumpStringKind(int $kind): string {
-        return $this->dumpEnum($kind, [
-            String_::KIND_SINGLE_QUOTED => 'KIND_SINGLE_QUOTED',
-            String_::KIND_DOUBLE_QUOTED => 'KIND_DOUBLE_QUOTED',
-            String_::KIND_HEREDOC => 'KIND_HEREDOC',
-            String_::KIND_NOWDOC => 'KIND_NOWDOC',
-        ]);
-    }
+        ];
 
-    private function dumpArrayKind(int $kind): string {
-        return $this->dumpEnum($kind, [
-            Array_::KIND_LONG => 'KIND_LONG',
-            Array_::KIND_SHORT => 'KIND_SHORT',
-        ]);
-    }
-
-    private function dumpListKind(int $kind): string {
-        return $this->dumpEnum($kind, [
-            List_::KIND_LIST => 'KIND_LIST',
-            List_::KIND_ARRAY => 'KIND_ARRAY',
-        ]);
+        if (!isset($map[$type])) {
+            return $type;
+        }
+        return $map[$type] . ' (' . $type . ')';
     }
 
     /**
@@ -258,7 +174,7 @@ class NodeDumper {
      *
      * @return string|null Dump of position, or null if position information not available
      */
-    protected function dumpPosition(Node $node): ?string {
+    protected function dumpPosition(Node $node) {
         if (!$node->hasAttribute('startLine') || !$node->hasAttribute('endLine')) {
             return null;
         }
@@ -275,7 +191,7 @@ class NodeDumper {
     }
 
     // Copied from Error class
-    private function toColumn(string $code, int $pos): int {
+    private function toColumn($code, $pos) {
         if ($pos > strlen($code)) {
             throw new \RuntimeException('Invalid position information');
         }

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

@@ -5,27 +5,25 @@ namespace PhpParser;
 use PhpParser\NodeVisitor\FindingVisitor;
 use PhpParser\NodeVisitor\FirstFindingVisitor;
 
-class NodeFinder {
+class NodeFinder
+{
     /**
      * Find all nodes satisfying a filter callback.
      *
-     * @param Node|Node[] $nodes Single node or array of nodes to search in
-     * @param callable $filter Filter callback: function(Node $node) : bool
+     * @param Node|Node[] $nodes  Single node or array of nodes to search in
+     * @param callable    $filter Filter callback: function(Node $node) : bool
      *
      * @return Node[] Found nodes satisfying the filter callback
      */
-    public function find($nodes, callable $filter): array {
-        if ($nodes === []) {
-            return [];
-        }
-
+    public function find($nodes, callable $filter) : array {
         if (!is_array($nodes)) {
             $nodes = [$nodes];
         }
 
         $visitor = new FindingVisitor($filter);
 
-        $traverser = new NodeTraverser($visitor);
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
         $traverser->traverse($nodes);
 
         return $visitor->getFoundNodes();
@@ -33,15 +31,13 @@ class NodeFinder {
 
     /**
      * Find all nodes that are instances of a certain class.
-
-     * @template TNode as Node
      *
      * @param Node|Node[] $nodes Single node or array of nodes to search in
-     * @param class-string<TNode> $class Class name
+     * @param string      $class Class name
      *
-     * @return TNode[] Found nodes (all instances of $class)
+     * @return Node[] Found nodes (all instances of $class)
      */
-    public function findInstanceOf($nodes, string $class): array {
+    public function findInstanceOf($nodes, string $class) : array {
         return $this->find($nodes, function ($node) use ($class) {
             return $node instanceof $class;
         });
@@ -50,23 +46,20 @@ class NodeFinder {
     /**
      * Find first node satisfying a filter callback.
      *
-     * @param Node|Node[] $nodes Single node or array of nodes to search in
-     * @param callable $filter Filter callback: function(Node $node) : bool
+     * @param Node|Node[] $nodes  Single node or array of nodes to search in
+     * @param callable    $filter Filter callback: function(Node $node) : bool
      *
      * @return null|Node Found node (or null if none found)
      */
-    public function findFirst($nodes, callable $filter): ?Node {
-        if ($nodes === []) {
-            return null;
-        }
-
+    public function findFirst($nodes, callable $filter) {
         if (!is_array($nodes)) {
             $nodes = [$nodes];
         }
 
         $visitor = new FirstFindingVisitor($filter);
 
-        $traverser = new NodeTraverser($visitor);
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
         $traverser->traverse($nodes);
 
         return $visitor->getFoundNode();
@@ -75,14 +68,12 @@ class NodeFinder {
     /**
      * Find first node that is an instance of a certain class.
      *
-     * @template TNode as Node
-     *
-     * @param Node|Node[] $nodes Single node or array of nodes to search in
-     * @param class-string<TNode> $class Class name
+     * @param Node|Node[] $nodes  Single node or array of nodes to search in
+     * @param string      $class Class name
      *
-     * @return null|TNode Found node, which is an instance of $class (or null if none found)
+     * @return null|Node Found node, which is an instance of $class (or null if none found)
      */
-    public function findFirstInstanceOf($nodes, string $class): ?Node {
+    public function findFirstInstanceOf($nodes, string $class) {
         return $this->findFirst($nodes, function ($node) use ($class) {
             return $node instanceof $class;
         });