@appthreat/atom-parsetools 1.0.4 → 1.0.6

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

@@ -2,14 +2,14 @@
 
 namespace PhpParser;
 
-abstract class NodeAbstract implements Node, \JsonSerializable
-{
-    protected $attributes;
+abstract class NodeAbstract implements Node, \JsonSerializable {
+    /** @var array<string, mixed> Attributes */
+    protected array $attributes;
 
     /**
      * Creates a Node.
      *
-     * @param array $attributes Array of attributes
+     * @param array<string, mixed> $attributes Array of attributes
      */
     public function __construct(array $attributes = []) {
         $this->attributes = $attributes;
@@ -19,8 +19,9 @@ abstract class NodeAbstract implements Node, \JsonSerializable
      * Gets line the node started in (alias of getStartLine).
      *
      * @return int Start line (or -1 if not available)
+     * @phpstan-return -1|positive-int
      */
-    public function getLine() : int {
+    public function getLine(): int {
         return $this->attributes['startLine'] ?? -1;
     }
 
@@ -30,8 +31,9 @@ abstract class NodeAbstract implements Node, \JsonSerializable
      * Requires the 'startLine' attribute to be enabled in the lexer (enabled by default).
      *
      * @return int Start line (or -1 if not available)
+     * @phpstan-return -1|positive-int
      */
-    public function getStartLine() : int {
+    public function getStartLine(): int {
         return $this->attributes['startLine'] ?? -1;
     }
 
@@ -41,8 +43,9 @@ abstract class NodeAbstract implements Node, \JsonSerializable
      * Requires the 'endLine' attribute to be enabled in the lexer (enabled by default).
      *
      * @return int End line (or -1 if not available)
+     * @phpstan-return -1|positive-int
      */
-    public function getEndLine() : int {
+    public function getEndLine(): int {
         return $this->attributes['endLine'] ?? -1;
     }
 
@@ -55,7 +58,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 +71,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 +82,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 +93,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 +104,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable
      *
      * @return Comment[]
      */
-    public function getComments() : array {
+    public function getComments(): array {
         return $this->attributes['comments'] ?? [];
     }
 
@@ -110,7 +113,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable
      *
      * @return null|Comment\Doc Doc comment object or null
      */
-    public function getDocComment() {
+    public function getDocComment(): ?Comment\Doc {
         $comments = $this->getComments();
         for ($i = count($comments) - 1; $i >= 0; $i--) {
             $comment = $comments[$i];
@@ -129,7 +132,7 @@ abstract class NodeAbstract implements Node, \JsonSerializable
      *
      * @param Comment\Doc $docComment Doc comment to set
      */
-    public function setDocComment(Comment\Doc $docComment) {
+    public function setDocComment(Comment\Doc $docComment): void {
         $comments = $this->getComments();
         for ($i = count($comments) - 1; $i >= 0; $i--) {
             if ($comments[$i] instanceof Comment\Doc) {
@@ -145,11 +148,11 @@ abstract class NodeAbstract implements Node, \JsonSerializable
         $this->setAttribute('comments', $comments);
     }
 
-    public function setAttribute(string $key, $value) {
+    public function setAttribute(string $key, $value): void {
         $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 +164,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) {
+    public function setAttributes(array $attributes): void {
         $this->attributes = $attributes;
     }
 
     /**
-     * @return array
+     * @return array<string, mixed>
      */
-    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,17 +2,33 @@
 
 namespace PhpParser;
 
+use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\Include_;
-use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Expr\List_;
+use PhpParser\Node\Scalar\Int_;
+use PhpParser\Node\Scalar\InterpolatedString;
+use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\GroupUse;
 use PhpParser\Node\Stmt\Use_;
-use PhpParser\Node\Stmt\UseUse;
+use PhpParser\Node\UseItem;
 
-class NodeDumper
-{
-    private $dumpComments;
-    private $dumpPositions;
-    private $code;
+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,
+    ];
 
     /**
      * Constructs a NodeDumper.
@@ -21,150 +37,227 @@ 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;
-        return $this->dumpRecursive($node);
+        $this->res = '';
+        $this->nl = "\n";
+        $this->dumpRecursive($node, false);
+        return $this->res;
     }
 
-    protected function dumpRecursive($node) {
+    /** @param mixed $node */
+    protected function dumpRecursive($node, bool $indent = true): void {
+        if ($indent) {
+            $this->nl .= "    ";
+        }
         if ($node instanceof Node) {
-            $r = $node->getType();
+            $this->res .= $node->getType();
             if ($this->dumpPositions && null !== $p = $this->dumpPosition($node)) {
-                $r .= $p;
+                $this->res .= $p;
             }
-            $r .= '(';
+            $this->res .= '(';
 
             foreach ($node->getSubNodeNames() as $key) {
-                $r .= "\n    " . $key . ': ';
+                $this->res .= "$this->nl    " . $key . ': ';
 
                 $value = $node->$key;
-                if (null === $value) {
-                    $r .= 'null';
-                } elseif (false === $value) {
-                    $r .= 'false';
-                } elseif (true === $value) {
-                    $r .= 'true';
-                } elseif (is_scalar($value)) {
+                if (\is_int($value)) {
                     if ('flags' === $key || 'newModifier' === $key) {
-                        $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;
+                        $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;
                     }
-                } else {
-                    $r .= str_replace("\n", "\n    ", $this->dumpRecursive($value));
                 }
+                $this->dumpRecursive($value);
             }
 
             if ($this->dumpComments && $comments = $node->getComments()) {
-                $r .= "\n    comments: " . str_replace("\n", "\n    ", $this->dumpRecursive($comments));
+                $this->res .= "$this->nl    comments: ";
+                $this->dumpRecursive($comments);
             }
-        } elseif (is_array($node)) {
-            $r = 'array(';
 
-            foreach ($node as $key => $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));
+            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);
+            }
+            $this->res .= "$this->nl)";
         } elseif ($node instanceof Comment) {
-            return $node->getReformattedText();
+            $this->res .= \str_replace("\n", $this->nl, $node->getReformattedText());
+        } elseif (\is_string($node)) {
+            $this->res .= \str_replace("\n", $this->nl, $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';
         } else {
             throw new \InvalidArgumentException('Can only dump nodes and arrays.');
         }
-
-        return $r . "\n)";
+        if ($indent) {
+            $this->nl = \substr($this->nl, 0, -4);
+        }
     }
 
-    protected function dumpFlags($flags) {
+    protected function dumpFlags(int $flags): string {
         $strs = [];
-        if ($flags & Class_::MODIFIER_PUBLIC) {
-            $strs[] = 'MODIFIER_PUBLIC';
+        if ($flags & Modifiers::PUBLIC) {
+            $strs[] = 'PUBLIC';
+        }
+        if ($flags & Modifiers::PROTECTED) {
+            $strs[] = 'PROTECTED';
+        }
+        if ($flags & Modifiers::PRIVATE) {
+            $strs[] = 'PRIVATE';
         }
-        if ($flags & Class_::MODIFIER_PROTECTED) {
-            $strs[] = 'MODIFIER_PROTECTED';
+        if ($flags & Modifiers::ABSTRACT) {
+            $strs[] = 'ABSTRACT';
         }
-        if ($flags & Class_::MODIFIER_PRIVATE) {
-            $strs[] = 'MODIFIER_PRIVATE';
+        if ($flags & Modifiers::STATIC) {
+            $strs[] = 'STATIC';
         }
-        if ($flags & Class_::MODIFIER_ABSTRACT) {
-            $strs[] = 'MODIFIER_ABSTRACT';
+        if ($flags & Modifiers::FINAL) {
+            $strs[] = 'FINAL';
         }
-        if ($flags & Class_::MODIFIER_STATIC) {
-            $strs[] = 'MODIFIER_STATIC';
+        if ($flags & Modifiers::READONLY) {
+            $strs[] = 'READONLY';
         }
-        if ($flags & Class_::MODIFIER_FINAL) {
-            $strs[] = 'MODIFIER_FINAL';
+        if ($flags & Modifiers::PUBLIC_SET) {
+            $strs[] = 'PUBLIC_SET';
         }
-        if ($flags & Class_::MODIFIER_READONLY) {
-            $strs[] = 'MODIFIER_READONLY';
+        if ($flags & Modifiers::PROTECTED_SET) {
+            $strs[] = 'PROTECTED_SET';
+        }
+        if ($flags & Modifiers::PRIVATE_SET) {
+            $strs[] = 'PRIVATE_SET';
         }
 
         if ($strs) {
             return implode(' | ', $strs) . ' (' . $flags . ')';
         } else {
-            return $flags;
+            return (string) $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 . ')';
     }
 
-    protected function dumpIncludeType($type) {
-        $map = [
+    private function dumpIncludeType(int $type): string {
+        return $this->dumpEnum($type, [
             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 . ')';
+        ]);
     }
 
-    protected function dumpUseType($type) {
-        $map = [
+    private function dumpUseType(int $type): string {
+        return $this->dumpEnum($type, [
             Use_::TYPE_UNKNOWN  => 'TYPE_UNKNOWN',
             Use_::TYPE_NORMAL   => 'TYPE_NORMAL',
             Use_::TYPE_FUNCTION => 'TYPE_FUNCTION',
             Use_::TYPE_CONSTANT => 'TYPE_CONSTANT',
-        ];
+        ]);
+    }
 
-        if (!isset($map[$type])) {
-            return $type;
-        }
-        return $map[$type] . ' (' . $type . ')';
+    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',
+        ]);
     }
 
     /**
@@ -174,7 +267,7 @@ class NodeDumper
      *
      * @return string|null Dump of position, or null if position information not available
      */
-    protected function dumpPosition(Node $node) {
+    protected function dumpPosition(Node $node): ?string {
         if (!$node->hasAttribute('startLine') || !$node->hasAttribute('endLine')) {
             return null;
         }
@@ -191,7 +284,7 @@ class NodeDumper
     }
 
     // Copied from Error class
-    private function toColumn($code, $pos) {
+    private function toColumn(string $code, int $pos): int {
         if ($pos > strlen($code)) {
             throw new \RuntimeException('Invalid position information');
         }

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

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