function Parser::expressionToPattern

Converts an expression node to a pattern node

Parameters

Node\Node $node The node to convert:

Return value

Node\Node

2 calls to Parser::expressionToPattern()

Parser::parseAssignmentExpression in vendor/mck89/peast/lib/Peast/Syntax/Parser.php

Parses an assignment expression

Parser::parseForNotVarLetConstStatement in vendor/mck89/peast/lib/Peast/Syntax/Parser.php

Parses a for statement that does not start with var, let or const

File

vendor/mck89/peast/lib/Peast/Syntax/Parser.php, line 234

Class

Parser

Parser class

Namespace

Peast\Syntax

Code

protected function expressionToPattern($node) {
    if ($node instanceof Node\ArrayExpression) {
        $loc = $node->location;
        $elems = array();
        foreach ($node->getElements() as $elem) {
            $elems[] = $this->expressionToPattern($elem);
        }
        $retNode = $this->createNode("ArrayPattern", $loc->start);
        $retNode->setElements($elems);
        $this->completeNode($retNode, $loc->end);
    }
    elseif ($node instanceof Node\ObjectExpression) {
        $loc = $node->location;
        $props = array();
        foreach ($node->getProperties() as $prop) {
            $props[] = $this->expressionToPattern($prop);
        }
        $retNode = $this->createNode("ObjectPattern", $loc->start);
        $retNode->setProperties($props);
        $this->completeNode($retNode, $loc->end);
    }
    elseif ($node instanceof Node\Property) {
        $loc = $node->location;
        $retNode = $this->createNode("AssignmentProperty", $loc->start);
        // If it's a shorthand property convert the value to an assignment
        // pattern if necessary
        $value = $node->getValue();
        $key = $node->getKey();
        if ($value && $node->getShorthand() && !$value instanceof Node\AssignmentExpression && (!$value instanceof Node\Identifier || $key instanceof Node\Identifier && $key->getName() !== $value->getName())) {
            $loc = $node->location;
            $valNode = $this->createNode("AssignmentPattern", $loc->start);
            $valNode->setLeft($key);
            $valNode->setRight($value);
            $this->completeNode($valNode, $loc->end);
            $value = $valNode;
        }
        else {
            $value = $this->expressionToPattern($value);
        }
        $retNode->setValue($value);
        $retNode->setKey($key);
        $retNode->setMethod($node->getMethod());
        $retNode->setShorthand($node->getShorthand());
        $retNode->setComputed($node->getComputed());
        $this->completeNode($retNode, $loc->end);
    }
    elseif ($node instanceof Node\SpreadElement) {
        $loc = $node->location;
        $retNode = $this->createNode("RestElement", $loc->start);
        $retNode->setArgument($this->expressionToPattern($node->getArgument()));
        $this->completeNode($retNode, $loc->end);
    }
    elseif ($node instanceof Node\AssignmentExpression) {
        $loc = $node->location;
        $retNode = $this->createNode("AssignmentPattern", $loc->start);
        $retNode->setLeft($this->expressionToPattern($node->getLeft()));
        $retNode->setRight($node->getRight());
        $this->completeNode($retNode, $loc->end);
    }
    else {
        $retNode = $node;
    }
    return $retNode;
}