@appthreat/atom 2.1.19 → 2.2.0

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

@@ -1,291 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser;
-
-class NodeTraverser implements NodeTraverserInterface
-{
-    /**
-     * If NodeVisitor::enterNode() returns DONT_TRAVERSE_CHILDREN, child nodes
-     * of the current node will not be traversed for any visitors.
-     *
-     * For subsequent visitors enterNode() will still be called on the current
-     * node and leaveNode() will also be invoked for the current node.
-     */
-    const DONT_TRAVERSE_CHILDREN = 1;
-
-    /**
-     * If NodeVisitor::enterNode() or NodeVisitor::leaveNode() returns
-     * STOP_TRAVERSAL, traversal is aborted.
-     *
-     * The afterTraverse() method will still be invoked.
-     */
-    const STOP_TRAVERSAL = 2;
-
-    /**
-     * If NodeVisitor::leaveNode() returns REMOVE_NODE for a node that occurs
-     * in an array, it will be removed from the array.
-     *
-     * For subsequent visitors leaveNode() will still be invoked for the
-     * removed node.
-     */
-    const REMOVE_NODE = 3;
-
-    /**
-     * If NodeVisitor::enterNode() returns DONT_TRAVERSE_CURRENT_AND_CHILDREN, child nodes
-     * of the current node will not be traversed for any visitors.
-     *
-     * For subsequent visitors enterNode() will not be called as well.
-     * leaveNode() will be invoked for visitors that has enterNode() method invoked.
-     */
-    const DONT_TRAVERSE_CURRENT_AND_CHILDREN = 4;
-
-    /** @var NodeVisitor[] Visitors */
-    protected $visitors = [];
-
-    /** @var bool Whether traversal should be stopped */
-    protected $stopTraversal;
-
-    public function __construct() {
-        // for BC
-    }
-
-    /**
-     * Adds a visitor.
-     *
-     * @param NodeVisitor $visitor Visitor to add
-     */
-    public function addVisitor(NodeVisitor $visitor) {
-        $this->visitors[] = $visitor;
-    }
-
-    /**
-     * Removes an added visitor.
-     *
-     * @param NodeVisitor $visitor
-     */
-    public function removeVisitor(NodeVisitor $visitor) {
-        foreach ($this->visitors as $index => $storedVisitor) {
-            if ($storedVisitor === $visitor) {
-                unset($this->visitors[$index]);
-                break;
-            }
-        }
-    }
-
-    /**
-     * Traverses an array of nodes using the registered visitors.
-     *
-     * @param Node[] $nodes Array of nodes
-     *
-     * @return Node[] Traversed array of nodes
-     */
-    public function traverse(array $nodes) : array {
-        $this->stopTraversal = false;
-
-        foreach ($this->visitors as $visitor) {
-            if (null !== $return = $visitor->beforeTraverse($nodes)) {
-                $nodes = $return;
-            }
-        }
-
-        $nodes = $this->traverseArray($nodes);
-
-        foreach ($this->visitors as $visitor) {
-            if (null !== $return = $visitor->afterTraverse($nodes)) {
-                $nodes = $return;
-            }
-        }
-
-        return $nodes;
-    }
-
-    /**
-     * Recursively traverse a node.
-     *
-     * @param Node $node Node to traverse.
-     *
-     * @return Node Result of traversal (may be original node or new one)
-     */
-    protected function traverseNode(Node $node) : Node {
-        foreach ($node->getSubNodeNames() as $name) {
-            $subNode =& $node->$name;
-
-            if (\is_array($subNode)) {
-                $subNode = $this->traverseArray($subNode);
-                if ($this->stopTraversal) {
-                    break;
-                }
-            } elseif ($subNode instanceof Node) {
-                $traverseChildren = true;
-                $breakVisitorIndex = null;
-
-                foreach ($this->visitors as $visitorIndex => $visitor) {
-                    $return = $visitor->enterNode($subNode);
-                    if (null !== $return) {
-                        if ($return instanceof Node) {
-                            $this->ensureReplacementReasonable($subNode, $return);
-                            $subNode = $return;
-                        } elseif (self::DONT_TRAVERSE_CHILDREN === $return) {
-                            $traverseChildren = false;
-                        } elseif (self::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
-                            $traverseChildren = false;
-                            $breakVisitorIndex = $visitorIndex;
-                            break;
-                        } elseif (self::STOP_TRAVERSAL === $return) {
-                            $this->stopTraversal = true;
-                            break 2;
-                        } else {
-                            throw new \LogicException(
-                                'enterNode() returned invalid value of type ' . gettype($return)
-                            );
-                        }
-                    }
-                }
-
-                if ($traverseChildren) {
-                    $subNode = $this->traverseNode($subNode);
-                    if ($this->stopTraversal) {
-                        break;
-                    }
-                }
-
-                foreach ($this->visitors as $visitorIndex => $visitor) {
-                    $return = $visitor->leaveNode($subNode);
-
-                    if (null !== $return) {
-                        if ($return instanceof Node) {
-                            $this->ensureReplacementReasonable($subNode, $return);
-                            $subNode = $return;
-                        } elseif (self::STOP_TRAVERSAL === $return) {
-                            $this->stopTraversal = true;
-                            break 2;
-                        } elseif (\is_array($return)) {
-                            throw new \LogicException(
-                                'leaveNode() may only return an array ' .
-                                'if the parent structure is an array'
-                            );
-                        } else {
-                            throw new \LogicException(
-                                'leaveNode() returned invalid value of type ' . gettype($return)
-                            );
-                        }
-                    }
-
-                    if ($breakVisitorIndex === $visitorIndex) {
-                        break;
-                    }
-                }
-            }
-        }
-
-        return $node;
-    }
-
-    /**
-     * Recursively traverse array (usually of nodes).
-     *
-     * @param array $nodes Array to traverse
-     *
-     * @return array Result of traversal (may be original array or changed one)
-     */
-    protected function traverseArray(array $nodes) : array {
-        $doNodes = [];
-
-        foreach ($nodes as $i => &$node) {
-            if ($node instanceof Node) {
-                $traverseChildren = true;
-                $breakVisitorIndex = null;
-
-                foreach ($this->visitors as $visitorIndex => $visitor) {
-                    $return = $visitor->enterNode($node);
-                    if (null !== $return) {
-                        if ($return instanceof Node) {
-                            $this->ensureReplacementReasonable($node, $return);
-                            $node = $return;
-                        } elseif (self::DONT_TRAVERSE_CHILDREN === $return) {
-                            $traverseChildren = false;
-                        } elseif (self::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
-                            $traverseChildren = false;
-                            $breakVisitorIndex = $visitorIndex;
-                            break;
-                        } elseif (self::STOP_TRAVERSAL === $return) {
-                            $this->stopTraversal = true;
-                            break 2;
-                        } else {
-                            throw new \LogicException(
-                                'enterNode() returned invalid value of type ' . gettype($return)
-                            );
-                        }
-                    }
-                }
-
-                if ($traverseChildren) {
-                    $node = $this->traverseNode($node);
-                    if ($this->stopTraversal) {
-                        break;
-                    }
-                }
-
-                foreach ($this->visitors as $visitorIndex => $visitor) {
-                    $return = $visitor->leaveNode($node);
-
-                    if (null !== $return) {
-                        if ($return instanceof Node) {
-                            $this->ensureReplacementReasonable($node, $return);
-                            $node = $return;
-                        } elseif (\is_array($return)) {
-                            $doNodes[] = [$i, $return];
-                            break;
-                        } elseif (self::REMOVE_NODE === $return) {
-                            $doNodes[] = [$i, []];
-                            break;
-                        } elseif (self::STOP_TRAVERSAL === $return) {
-                            $this->stopTraversal = true;
-                            break 2;
-                        } elseif (false === $return) {
-                            throw new \LogicException(
-                                'bool(false) return from leaveNode() no longer supported. ' .
-                                'Return NodeTraverser::REMOVE_NODE instead'
-                            );
-                        } else {
-                            throw new \LogicException(
-                                'leaveNode() returned invalid value of type ' . gettype($return)
-                            );
-                        }
-                    }
-
-                    if ($breakVisitorIndex === $visitorIndex) {
-                        break;
-                    }
-                }
-            } elseif (\is_array($node)) {
-                throw new \LogicException('Invalid node structure: Contains nested arrays');
-            }
-        }
-
-        if (!empty($doNodes)) {
-            while (list($i, $replace) = array_pop($doNodes)) {
-                array_splice($nodes, $i, 1, $replace);
-            }
-        }
-
-        return $nodes;
-    }
-
-    private function ensureReplacementReasonable($old, $new) {
-        if ($old instanceof Node\Stmt && $new instanceof Node\Expr) {
-            throw new \LogicException(
-                "Trying to replace statement ({$old->getType()}) " .
-                "with expression ({$new->getType()}). Are you missing a " .
-                "Stmt_Expression wrapper?"
-            );
-        }
-
-        if ($old instanceof Node\Expr && $new instanceof Node\Stmt) {
-            throw new \LogicException(
-                "Trying to replace expression ({$old->getType()}) " .
-                "with statement ({$new->getType()})"
-            );
-        }
-    }
-}

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

@@ -1,29 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser;
-
-interface NodeTraverserInterface
-{
-    /**
-     * Adds a visitor.
-     *
-     * @param NodeVisitor $visitor Visitor to add
-     */
-    public function addVisitor(NodeVisitor $visitor);
-
-    /**
-     * Removes an added visitor.
-     *
-     * @param NodeVisitor $visitor
-     */
-    public function removeVisitor(NodeVisitor $visitor);
-
-    /**
-     * Traverses an array of nodes using the registered visitors.
-     *
-     * @param Node[] $nodes Array of nodes
-     *
-     * @return Node[] Traversed array of nodes
-     */
-    public function traverse(array $nodes) : array;
-}

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php

@@ -1,20 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser\NodeVisitor;
-
-use PhpParser\Node;
-use PhpParser\NodeVisitorAbstract;
-
-/**
- * Visitor cloning all nodes and linking to the original nodes using an attribute.
- *
- * This visitor is required to perform format-preserving pretty prints.
- */
-class CloningVisitor extends NodeVisitorAbstract
-{
-    public function enterNode(Node $origNode) {
-        $node = clone $origNode;
-        $node->setAttribute('origNode', $origNode);
-        return $node;
-    }
-}

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php

@@ -1,48 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser\NodeVisitor;
-
-use PhpParser\Node;
-use PhpParser\NodeVisitorAbstract;
-
-/**
- * This visitor can be used to find and collect all nodes satisfying some criterion determined by
- * a filter callback.
- */
-class FindingVisitor extends NodeVisitorAbstract
-{
-    /** @var callable Filter callback */
-    protected $filterCallback;
-    /** @var Node[] Found nodes */
-    protected $foundNodes;
-
-    public function __construct(callable $filterCallback) {
-        $this->filterCallback = $filterCallback;
-    }
-
-    /**
-     * Get found nodes satisfying the filter callback.
-     *
-     * Nodes are returned in pre-order.
-     *
-     * @return Node[] Found nodes
-     */
-    public function getFoundNodes() : array {
-        return $this->foundNodes;
-    }
-
-    public function beforeTraverse(array $nodes) {
-        $this->foundNodes = [];
-
-        return null;
-    }
-
-    public function enterNode(Node $node) {
-        $filterCallback = $this->filterCallback;
-        if ($filterCallback($node)) {
-            $this->foundNodes[] = $node;
-        }
-
-        return null;
-    }
-}

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php

@@ -1,50 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser\NodeVisitor;
-
-use PhpParser\Node;
-use PhpParser\NodeTraverser;
-use PhpParser\NodeVisitorAbstract;
-
-/**
- * This visitor can be used to find the first node satisfying some criterion determined by
- * a filter callback.
- */
-class FirstFindingVisitor extends NodeVisitorAbstract
-{
-    /** @var callable Filter callback */
-    protected $filterCallback;
-    /** @var null|Node Found node */
-    protected $foundNode;
-
-    public function __construct(callable $filterCallback) {
-        $this->filterCallback = $filterCallback;
-    }
-
-    /**
-     * Get found node satisfying the filter callback.
-     *
-     * Returns null if no node satisfies the filter callback.
-     *
-     * @return null|Node Found node (or null if not found)
-     */
-    public function getFoundNode() {
-        return $this->foundNode;
-    }
-
-    public function beforeTraverse(array $nodes) {
-        $this->foundNode = null;
-
-        return null;
-    }
-
-    public function enterNode(Node $node) {
-        $filterCallback = $this->filterCallback;
-        if ($filterCallback($node)) {
-            $this->foundNode = $node;
-            return NodeTraverser::STOP_TRAVERSAL;
-        }
-
-        return null;
-    }
-}

package/plugins/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php

@@ -1,260 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser\NodeVisitor;
-
-use PhpParser\ErrorHandler;
-use PhpParser\NameContext;
-use PhpParser\Node;
-use PhpParser\Node\Expr;
-use PhpParser\Node\Name;
-use PhpParser\Node\Name\FullyQualified;
-use PhpParser\Node\Stmt;
-use PhpParser\NodeVisitorAbstract;
-
-class NameResolver extends NodeVisitorAbstract
-{
-    /** @var NameContext Naming context */
-    protected $nameContext;
-
-    /** @var bool Whether to preserve original names */
-    protected $preserveOriginalNames;
-
-    /** @var bool Whether to replace resolved nodes in place, or to add resolvedNode attributes */
-    protected $replaceNodes;
-
-    /**
-     * Constructs a name resolution visitor.
-     *
-     * Options:
-     *  * preserveOriginalNames (default false): An "originalName" attribute will be added to
-     *    all name nodes that underwent resolution.
-     *  * replaceNodes (default true): Resolved names are replaced in-place. Otherwise, a
-     *    resolvedName attribute is added. (Names that cannot be statically resolved receive a
-     *    namespacedName attribute, as usual.)
-     *
-     * @param ErrorHandler|null $errorHandler Error handler
-     * @param array $options Options
-     */
-    public function __construct(ErrorHandler $errorHandler = null, array $options = []) {
-        $this->nameContext = new NameContext($errorHandler ?? new ErrorHandler\Throwing);
-        $this->preserveOriginalNames = $options['preserveOriginalNames'] ?? false;
-        $this->replaceNodes = $options['replaceNodes'] ?? true;
-    }
-
-    /**
-     * Get name resolution context.
-     *
-     * @return NameContext
-     */
-    public function getNameContext() : NameContext {
-        return $this->nameContext;
-    }
-
-    public function beforeTraverse(array $nodes) {
-        $this->nameContext->startNamespace();
-        return null;
-    }
-
-    public function enterNode(Node $node) {
-        if ($node instanceof Stmt\Namespace_) {
-            $this->nameContext->startNamespace($node->name);
-        } elseif ($node instanceof Stmt\Use_) {
-            foreach ($node->uses as $use) {
-                $this->addAlias($use, $node->type, null);
-            }
-        } elseif ($node instanceof Stmt\GroupUse) {
-            foreach ($node->uses as $use) {
-                $this->addAlias($use, $node->type, $node->prefix);
-            }
-        } elseif ($node instanceof Stmt\Class_) {
-            if (null !== $node->extends) {
-                $node->extends = $this->resolveClassName($node->extends);
-            }
-
-            foreach ($node->implements as &$interface) {
-                $interface = $this->resolveClassName($interface);
-            }
-
-            $this->resolveAttrGroups($node);
-            if (null !== $node->name) {
-                $this->addNamespacedName($node);
-            }
-        } elseif ($node instanceof Stmt\Interface_) {
-            foreach ($node->extends as &$interface) {
-                $interface = $this->resolveClassName($interface);
-            }
-
-            $this->resolveAttrGroups($node);
-            $this->addNamespacedName($node);
-         } elseif ($node instanceof Stmt\Enum_) {
-            foreach ($node->implements as &$interface) {
-                $interface = $this->resolveClassName($interface);
-            }
-
-            $this->resolveAttrGroups($node);
-            if (null !== $node->name) {
-                $this->addNamespacedName($node);
-            }
-        } elseif ($node instanceof Stmt\Trait_) {
-            $this->resolveAttrGroups($node);
-            $this->addNamespacedName($node);
-        } elseif ($node instanceof Stmt\Function_) {
-            $this->resolveSignature($node);
-            $this->resolveAttrGroups($node);
-            $this->addNamespacedName($node);
-        } elseif ($node instanceof Stmt\ClassMethod
-                  || $node instanceof Expr\Closure
-                  || $node instanceof Expr\ArrowFunction
-        ) {
-            $this->resolveSignature($node);
-            $this->resolveAttrGroups($node);
-        } elseif ($node instanceof Stmt\Property) {
-            if (null !== $node->type) {
-                $node->type = $this->resolveType($node->type);
-            }
-            $this->resolveAttrGroups($node);
-        } elseif ($node instanceof Stmt\Const_) {
-            foreach ($node->consts as $const) {
-                $this->addNamespacedName($const);
-            }
-        } else if ($node instanceof Stmt\ClassConst) {
-            if (null !== $node->type) {
-                $node->type = $this->resolveType($node->type);
-            }
-            $this->resolveAttrGroups($node);
-        } else if ($node instanceof Stmt\EnumCase) {
-            $this->resolveAttrGroups($node);
-        } elseif ($node instanceof Expr\StaticCall
-                  || $node instanceof Expr\StaticPropertyFetch
-                  || $node instanceof Expr\ClassConstFetch
-                  || $node instanceof Expr\New_
-                  || $node instanceof Expr\Instanceof_
-        ) {
-            if ($node->class instanceof Name) {
-                $node->class = $this->resolveClassName($node->class);
-            }
-        } elseif ($node instanceof Stmt\Catch_) {
-            foreach ($node->types as &$type) {
-                $type = $this->resolveClassName($type);
-            }
-        } elseif ($node instanceof Expr\FuncCall) {
-            if ($node->name instanceof Name) {
-                $node->name = $this->resolveName($node->name, Stmt\Use_::TYPE_FUNCTION);
-            }
-        } elseif ($node instanceof Expr\ConstFetch) {
-            $node->name = $this->resolveName($node->name, Stmt\Use_::TYPE_CONSTANT);
-        } elseif ($node instanceof Stmt\TraitUse) {
-            foreach ($node->traits as &$trait) {
-                $trait = $this->resolveClassName($trait);
-            }
-
-            foreach ($node->adaptations as $adaptation) {
-                if (null !== $adaptation->trait) {
-                    $adaptation->trait = $this->resolveClassName($adaptation->trait);
-                }
-
-                if ($adaptation instanceof Stmt\TraitUseAdaptation\Precedence) {
-                    foreach ($adaptation->insteadof as &$insteadof) {
-                        $insteadof = $this->resolveClassName($insteadof);
-                    }
-                }
-            }
-        }
-
-        return null;
-    }
-
-    private function addAlias(Stmt\UseUse $use, int $type, Name $prefix = null) {
-        // Add prefix for group uses
-        $name = $prefix ? Name::concat($prefix, $use->name) : $use->name;
-        // Type is determined either by individual element or whole use declaration
-        $type |= $use->type;
-
-        $this->nameContext->addAlias(
-            $name, (string) $use->getAlias(), $type, $use->getAttributes()
-        );
-    }
-
-    /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure $node */
-    private function resolveSignature($node) {
-        foreach ($node->params as $param) {
-            $param->type = $this->resolveType($param->type);
-            $this->resolveAttrGroups($param);
-        }
-        $node->returnType = $this->resolveType($node->returnType);
-    }
-
-    private function resolveType($node) {
-        if ($node instanceof Name) {
-            return $this->resolveClassName($node);
-        }
-        if ($node instanceof Node\NullableType) {
-            $node->type = $this->resolveType($node->type);
-            return $node;
-        }
-        if ($node instanceof Node\UnionType || $node instanceof Node\IntersectionType) {
-            foreach ($node->types as &$type) {
-                $type = $this->resolveType($type);
-            }
-            return $node;
-        }
-        return $node;
-    }
-
-    /**
-     * Resolve name, according to name resolver options.
-     *
-     * @param Name $name Function or constant name to resolve
-     * @param int  $type One of Stmt\Use_::TYPE_*
-     *
-     * @return Name Resolved name, or original name with attribute
-     */
-    protected function resolveName(Name $name, int $type) : Name {
-        if (!$this->replaceNodes) {
-            $resolvedName = $this->nameContext->getResolvedName($name, $type);
-            if (null !== $resolvedName) {
-                $name->setAttribute('resolvedName', $resolvedName);
-            } else {
-                $name->setAttribute('namespacedName', FullyQualified::concat(
-                    $this->nameContext->getNamespace(), $name, $name->getAttributes()));
-            }
-            return $name;
-        }
-
-        if ($this->preserveOriginalNames) {
-            // Save the original name
-            $originalName = $name;
-            $name = clone $originalName;
-            $name->setAttribute('originalName', $originalName);
-        }
-
-        $resolvedName = $this->nameContext->getResolvedName($name, $type);
-        if (null !== $resolvedName) {
-            return $resolvedName;
-        }
-
-        // unqualified names inside a namespace cannot be resolved at compile-time
-        // add the namespaced version of the name as an attribute
-        $name->setAttribute('namespacedName', FullyQualified::concat(
-            $this->nameContext->getNamespace(), $name, $name->getAttributes()));
-        return $name;
-    }
-
-    protected function resolveClassName(Name $name) {
-        return $this->resolveName($name, Stmt\Use_::TYPE_NORMAL);
-    }
-
-    protected function addNamespacedName(Node $node) {
-        $node->namespacedName = Name::concat(
-            $this->nameContext->getNamespace(), (string) $node->name);
-    }
-
-    protected function resolveAttrGroups(Node $node)
-    {
-        foreach ($node->attrGroups as $attrGroup) {
-            foreach ($attrGroup->attrs as $attr) {
-                $attr->name = $this->resolveClassName($attr->name);
-            }
-        }
-    }
-}