function NodeTraverser::traverseArray

Same name in this branch

1. 11.1.x vendor/nikic/php-parser/lib/PhpParser/NodeTraverser.php \PhpParser\NodeTraverser::traverseArray()

* Recursively traverse array (usually of nodes). * *

Parameters

mixed[] $nodes Array to traverse: * * @return mixed[] Result of traversal (may be original array or changed one)

2 calls to NodeTraverser::traverseArray()

NodeTraverser::traverse in vendor/phpstan/phpdoc-parser/src/Ast/NodeTraverser.php

* Traverses an array of nodes using the registered visitors. * *

NodeTraverser::traverseNode in vendor/phpstan/phpdoc-parser/src/Ast/NodeTraverser.php

* Recursively traverse a node. * *

File

vendor/phpstan/phpdoc-parser/src/Ast/NodeTraverser.php, line 205

Class

NodeTraverser

Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd49…

Namespace

PHPStan\PhpDocParser\Ast

Code

private 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 ($return === null) {
                    continue;
                }
                if ($return instanceof Node) {
                    $this->ensureReplacementReasonable($node, $return);
                    $node = $return;
                }
                elseif (is_array($return)) {
                    $doNodes[] = [
                        $i,
                        $return,
                    ];
                    continue 2;
                }
                elseif ($return === self::REMOVE_NODE) {
                    $doNodes[] = [
                        $i,
                        [],
                    ];
                    continue 2;
                }
                elseif ($return === self::DONT_TRAVERSE_CHILDREN) {
                    $traverseChildren = false;
                }
                elseif ($return === self::DONT_TRAVERSE_CURRENT_AND_CHILDREN) {
                    $traverseChildren = false;
                    $breakVisitorIndex = $visitorIndex;
                    break;
                }
                elseif ($return === self::STOP_TRAVERSAL) {
                    $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 ($return !== null) {
                    if ($return instanceof Node) {
                        $this->ensureReplacementReasonable($node, $return);
                        $node = $return;
                    }
                    elseif (is_array($return)) {
                        $doNodes[] = [
                            $i,
                            $return,
                        ];
                        break;
                    }
                    elseif ($return === self::REMOVE_NODE) {
                        $doNodes[] = [
                            $i,
                            [],
                        ];
                        break;
                    }
                    elseif ($return === self::STOP_TRAVERSAL) {
                        $this->stopTraversal = true;
                        break 2;
                    }
                    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 (count($doNodes) > 0) {
        while ([
            $i,
            $replace,
        ] = array_pop($doNodes)) {
            array_splice($nodes, $i, 1, $replace);
        }
    }
    return $nodes;
}