AST::parseParameterNode() - Code Metrics - TimeToogo/Pinq - Measure and Improve Code Quality continuously with Scrutinizer

AST::parseParameterNode() B
last analyzed 2017-09-06 06:30 UTC

↳ Parent: AST

Complexity

Conditions	6
Paths	3

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	8.8571
c	0
b	0
f	0
cc	6
eloc	13
nc	3
nop	1

<?php

namespace Pinq\Parsing\PhpParser;

use PhpParser\Node;
use Pinq\Expressions as O;
use Pinq\Expressions\Expression;
use Pinq\Expressions\Operators;
use Pinq\Parsing\ASTException;

/**
 * Converts the PHP-Parser nodes into the equivalent expression tree.
 *
 * @author Elliot Levin <[email protected]>
 */
class AST
{
    /**
     * @var Node[]
     */
    private $nodes = [];

    public function __construct(array $nodes)
    {
        $this->nodes = $nodes;
    }

    /**
     * Converts the supplied php parser nodes to an equivalent
     * expression tree.
     *
     * @param Node[] $nodes
     *
     * @return Expression[]
     */
    public static function convert(array $nodes)
    {
        return (new self($nodes))->getExpressions();
    }

    /**
     * Parses the nodes into the equivalent expression tree
     *
     * @return Expression[]
     */
    public function getExpressions()
    {
        return $this->parseNodes($this->nodes);
    }

    /**
     * @param Node[] $nodes
     *
     * @return Expression[]
     */
    private function parseNodes(array $nodes)
    {
        return array_map(
                function ($node) {
                    return $this->parseNode($node);
                },
                $nodes
        );
    }

    /**
     * @param Node $node
     *
     * @throws \Pinq\Parsing\ASTException
     * @return Expression
     */
    protected function parseNode(Node $node)
    {
        switch (true) {
            case $node instanceof Node\Stmt:
                return $this->parseStatementNode($node);

            case $node instanceof Node\Expr:
                return $this->parseExpressionNode($node);

            case $node instanceof Node\Param:
                return $this->parseParameterNode($node);

            case $node instanceof Node\Arg:
                return $this->parseArgumentNode($node);

            default:
                throw new ASTException('Unsupported node type: %s', get_class($node));
        }
    }

    /**
     * @param $node
     *
     * @return Expression
     */
    final public function parseNameNode($node)
    {
        if ($node instanceof Node\Name) {
            return Expression::value($this->parseAbsoluteName($node));
        } elseif (is_string($node)) {
            return Expression::value($node);
        }

        return $this->parseNode($node);
    }

    protected function parseAbsoluteName(Node\Name $node)
    {
        return ($node->isFullyQualified() ? '\\' : '') . (string) $node;
    }

    private function parseParameterNode(Node\Param $node)
    {
        $type = $node->type;
        if ($type !== null) {
            $type      = (string) $type;
            $lowerType = strtolower($type);
            if ($type[0] !== '\\' && $lowerType !== 'array' && $lowerType !== 'callable') {
                $type = '\\' . $type;
            }
        }

        return Expression::parameter(
                $node->name,
                $type,
                $node->default === null ? null : $this->parseNode($node->default),
                $node->byRef,
                $node->variadic
        );
    }

    private function parseArgumentNode(Node\Arg $node)
    {
        return Expression::argument(
                $this->parseNode($node->value),
                $node->unpack
        );
    }

    // <editor-fold defaultstate="collapsed" desc="Expression node parsers">

    public function parseExpressionNode(Node\Expr $node)
    {
        switch (true) {
            case $mappedNode = $this->parseOperatorNode($node):
                return $mappedNode;

            case $node instanceof Node\Scalar
                    && $mappedNode = $this->parseScalarNode($node):
                return $mappedNode;

            case $node instanceof Node\Expr\Variable:
                return Expression::variable($this->parseNameNode($node->name));

            case $node instanceof Node\Expr\Array_:
                return $this->parseArrayNode($node);

            case $node instanceof Node\Expr\FuncCall:
                return $this->parseFunctionCallNode($node);

            case $node instanceof Node\Expr\New_:
                return Expression::newExpression(
                        $this->parseNameNode($node->class),
                        $this->parseNodes($node->args)
                );

            case $node instanceof Node\Expr\MethodCall:
                return Expression::methodCall(
                        $this->parseNode($node->var),
                        $this->parseNameNode($node->name),
                        $this->parseNodes($node->args)
                );

            case $node instanceof Node\Expr\PropertyFetch:
                return Expression::field(
                        $this->parseNode($node->var),
                        $this->parseNameNode($node->name)
                );

            case $node instanceof Node\Expr\ArrayDimFetch:
                return Expression::index(
                        $this->parseNode($node->var),
                        $node->dim === null ? null : $this->parseNode($node->dim)
                );

            case $node instanceof Node\Expr\ConstFetch:
                return Expression::constant($this->parseAbsoluteName($node->name));

            case $node instanceof Node\Expr\ClassConstFetch:
                return Expression::classConstant(
                        $this->parseNameNode($node->class),
                        $node->name
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                );

            case $node instanceof Node\Expr\StaticCall:
                return Expression::staticMethodCall(
                        $this->parseNameNode($node->class),
                        $this->parseNameNode($node->name),
                        $this->parseNodes($node->args)
                );

            case $node instanceof Node\Expr\StaticPropertyFetch:
                return Expression::staticField(
                        $this->parseNameNode($node->class),
                        $this->parseNameNode($node->name)
                );

            case $node instanceof Node\Expr\Ternary:
                return $this->parseTernaryNode($node);

            case $node instanceof Node\Expr\Closure:
                return $this->parseClosureNode($node);

            case $node instanceof Node\Expr\Empty_:
                return Expression::emptyExpression($this->parseNode($node->expr));

            case $node instanceof Node\Expr\Isset_:
                return Expression::issetExpression($this->parseNodes($node->vars));

            default:
                throw new ASTException(
                        'Cannot parse AST with unknown expression node: %s',
                        get_class($node));
        }
    }

    private function parseArrayNode(Node\Expr\Array_ $node)
    {
        $itemExpressions = [];

        foreach ($node->items as $item) {
            //Keys must match
            $itemExpressions[] = Expression::arrayItem(
                    $item->key === null ? null : $this->parseNode($item->key),
                    $this->parseNode($item->value),
                    $item->byRef
            );
        }

        return Expression::arrayExpression($itemExpressions);
    }

    private function parseFunctionCallNode(Node\Expr\FuncCall $node)
    {
        $nameExpression = $this->parseNameNode($node->name);

        if ($nameExpression instanceof O\TraversalExpression || $nameExpression instanceof O\VariableExpression) {
            return Expression::invocation(
                    $nameExpression,
                    $this->parseNodes($node->args)
            );
        } else {
            return Expression::functionCall(
                    $nameExpression,
                    $this->parseNodes($node->args)
            );
        }
    }

    private function parseTernaryNode(Node\Expr\Ternary $node)
    {
        return Expression::ternary(
                $this->parseNode($node->cond),
                $node->if === null ? null : $this->parseNode($node->if),
                $this->parseNode($node->else)
        );
    }

    private function parseClosureNode(Node\Expr\Closure $node)
    {
        $parameterExpressions = [];

        foreach ($node->params as $parameterNode) {
            $parameterExpressions[] = $this->parseParameterNode($parameterNode);
        }

        $usedVariables = [];
        foreach ($node->uses as $usedVariable) {
            $usedVariables[] = Expression::closureUsedVariable($usedVariable->var, $usedVariable->byRef);
        }
        $bodyExpressions = $this->parseNodes($node->stmts);

        return Expression::closure(
                $node->byRef,
                $node->static,
                $parameterExpressions,
                $usedVariables,
                $bodyExpressions
        );
    }

    private function parseScalarNode(Node\Scalar $node)
    {
        switch (true) {
            case $node instanceof Node\Scalar\DNumber:
            case $node instanceof Node\Scalar\LNumber:
            case $node instanceof Node\Scalar\String_:
                return Expression::value($node->value);

            case $node instanceof Node\Scalar\MagicConst\Line:
                return Expression::value($node->getAttribute('startLine'));

            case $node instanceof Node\Scalar\MagicConst:
                return Expression::constant($node->getName());

            default:
                return;
        }
    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Statement node parsers">

    private function parseStatementNode(Node\Stmt $node)
    {
        switch (true) {

            case $node instanceof Node\Stmt\Return_:
                return Expression::returnExpression($node->expr !== null ? $this->parseNode($node->expr) : null);

            case $node instanceof Node\Stmt\Throw_:
                return Expression::throwExpression($this->parseNode($node->expr));

            case $node instanceof Node\Stmt\Unset_:
                return Expression::unsetExpression($this->parseNodes($node->vars));

            default:
                $this->verifyNotControlStructure($node);
                throw new ASTException(
                        'Cannot parse AST with unknown statement node: %s',
                        get_class($node));
        }
    }

    private static $constructStructureMap = [
            'Do'       => ASTException::DO_WHILE_LOOP,
            'For'      => ASTException::FOR_LOOP,
            'Foreach'  => ASTException::FOREACH_LOOP,
            'Goto'     => ASTException::GOTO_STATEMENT,
            'If'       => ASTException::IF_STATEMENT,
            'Switch'   => ASTException::SWITCH_STATEMENT,
            'TryCatch' => ASTException::TRY_CATCH_STATEMENT,
            'While'    => ASTException::WHILE_LOOP
    ];

    private function verifyNotControlStructure(Node\Stmt $node)
    {
        $nodeType = str_replace('Stmt_', '', $node->getType());

        if (isset(self::$constructStructureMap[$nodeType])) {
            throw ASTException::containsControlStructure(
                    self::$constructStructureMap[$nodeType],
                    $node->getAttribute('startLine')
            );
        }
    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Operator node maps">

    private function parseOperatorNode(Node\Expr $node)
    {
        $nodeType = str_replace('Expr_', '', $node->getType());
        switch (true) {

            case isset(self::$assignOperatorsMap[$nodeType]):
                return Expression::assign(
                        $this->parseNode($node->var),
                        self::$assignOperatorsMap[$nodeType],
                        $this->parseNode($node->expr)
                );

            case $node instanceof Node\Expr\Instanceof_:
                return Expression::binaryOperation(
                        $this->parseNode($node->expr),
                        Operators\Binary::IS_INSTANCE_OF,
                        $this->parseNameNode($node->class)
                );

            case isset(self::$binaryOperatorsMap[$nodeType]):
                return Expression::binaryOperation(
                        $this->parseNode($node->left),
                        self::$binaryOperatorsMap[$nodeType],
                        $this->parseNode($node->right)
                );

            case isset(self::$unaryOperatorsMap[$nodeType]):
                return Expression::unaryOperation(
                        self::$unaryOperatorsMap[$nodeType],
                        $this->parseNode(isset($node->expr) ? $node->expr : $node->var)
                );

            case isset(self::$castOperatorMap[$nodeType]):
                return Expression::cast(
                        self::$castOperatorMap[$nodeType],
                        $this->parseNode($node->expr)
                );

            default:
                return null;
        }
    }

    private static $unaryOperatorsMap = [
            'BitwiseNot' => Operators\Unary::BITWISE_NOT,
            'BooleanNot' => Operators\Unary::NOT,
            'PostInc'    => Operators\Unary::INCREMENT,
            'PostDec'    => Operators\Unary::DECREMENT,
            'PreInc'     => Operators\Unary::PRE_INCREMENT,
            'PreDec'     => Operators\Unary::PRE_DECREMENT,
            'UnaryMinus' => Operators\Unary::NEGATION,
            'UnaryPlus'  => Operators\Unary::PLUS
    ];

    private static $castOperatorMap = [
            'Cast_Array'  => Operators\Cast::ARRAY_CAST,
            'Cast_Bool'   => Operators\Cast::BOOLEAN,
            'Cast_Double' => Operators\Cast::DOUBLE,
            'Cast_Int'    => Operators\Cast::INTEGER,
            'Cast_Object' => Operators\Cast::OBJECT,
            'Cast_String' => Operators\Cast::STRING
    ];

    private static $binaryOperatorsMap = [
            'BinaryOp_BitwiseAnd'     => Operators\Binary::BITWISE_AND,
            'BinaryOp_BitwiseOr'      => Operators\Binary::BITWISE_OR,
            'BinaryOp_BitwiseXor'     => Operators\Binary::BITWISE_XOR,
            'BinaryOp_ShiftLeft'      => Operators\Binary::SHIFT_LEFT,
            'BinaryOp_ShiftRight'     => Operators\Binary::SHIFT_RIGHT,
            'BinaryOp_BooleanAnd'     => Operators\Binary::LOGICAL_AND,
            'BinaryOp_BooleanOr'      => Operators\Binary::LOGICAL_OR,
            'BinaryOp_LogicalAnd'     => Operators\Binary::LOGICAL_AND,
            'BinaryOp_LogicalOr'      => Operators\Binary::LOGICAL_OR,
            'BinaryOp_Plus'           => Operators\Binary::ADDITION,
            'BinaryOp_Minus'          => Operators\Binary::SUBTRACTION,
            'BinaryOp_Mul'            => Operators\Binary::MULTIPLICATION,
            'BinaryOp_Div'            => Operators\Binary::DIVISION,
            'BinaryOp_Mod'            => Operators\Binary::MODULUS,
            'BinaryOp_Pow'            => Operators\Binary::POWER,
            'BinaryOp_Concat'         => Operators\Binary::CONCATENATION,
            'BinaryOp_Equal'          => Operators\Binary::EQUALITY,
            'BinaryOp_Identical'      => Operators\Binary::IDENTITY,
            'BinaryOp_NotEqual'       => Operators\Binary::INEQUALITY,
            'BinaryOp_NotIdentical'   => Operators\Binary::NOT_IDENTICAL,
            'BinaryOp_Smaller'        => Operators\Binary::LESS_THAN,
            'BinaryOp_SmallerOrEqual' => Operators\Binary::LESS_THAN_OR_EQUAL_TO,
            'BinaryOp_Greater'        => Operators\Binary::GREATER_THAN,
            'BinaryOp_GreaterOrEqual' => Operators\Binary::GREATER_THAN_OR_EQUAL_TO
    ];

    private static $assignOperatorsMap = [
            'Assign'              => Operators\Assignment::EQUAL,
            'AssignRef'           => Operators\Assignment::EQUAL_REFERENCE,
            'AssignOp_BitwiseAnd' => Operators\Assignment::BITWISE_AND,
            'AssignOp_BitwiseOr'  => Operators\Assignment::BITWISE_OR,
            'AssignOp_BitwiseXor' => Operators\Assignment::BITWISE_XOR,
            'AssignOp_Concat'     => Operators\Assignment::CONCATENATE,
            'AssignOp_Div'        => Operators\Assignment::DIVISION,
            'AssignOp_Minus'      => Operators\Assignment::SUBTRACTION,
            'AssignOp_Mod'        => Operators\Assignment::MODULUS,
            'AssignOp_Mul'        => Operators\Assignment::MULTIPLICATION,
            'AssignOp_Pow'        => Operators\Assignment::POWER,
            'AssignOp_Plus'       => Operators\Assignment::ADDITION,
            'AssignOp_ShiftLeft'  => Operators\Assignment::SHIFT_LEFT,
            'AssignOp_ShiftRight' => Operators\Assignment::SHIFT_RIGHT
    ];

    // </editor-fold>
}


1		<?php
2
3		namespace Pinq\Parsing\PhpParser;
4
5		use PhpParser\Node;
6		use Pinq\Expressions as O;
7		use Pinq\Expressions\Expression;
8		use Pinq\Expressions\Operators;
9		use Pinq\Parsing\ASTException;
10
11		/**
12		* Converts the PHP-Parser nodes into the equivalent expression tree.
13		*
14		* @author Elliot Levin <[email protected]>
15		*/
16		class AST
17		{
18		/**
19		* @var Node[]
20		*/
21		private $nodes = [];
22
23		public function __construct(array $nodes)
24		{
25		$this->nodes = $nodes;
26		}
27
28		/**
29		* Converts the supplied php parser nodes to an equivalent
30		* expression tree.
31		*
32		* @param Node[] $nodes
33		*
34		* @return Expression[]
35		*/
36		public static function convert(array $nodes)
37		{
38		return (new self($nodes))->getExpressions();
39		}
40
41		/**
42		* Parses the nodes into the equivalent expression tree
43		*
44		* @return Expression[]
45		*/
46		public function getExpressions()
47		{
48		return $this->parseNodes($this->nodes);
49		}
50
51		/**
52		* @param Node[] $nodes
53		*
54		* @return Expression[]
55		*/
56		private function parseNodes(array $nodes)
57		{
58		return array_map(
59		function ($node) {
60		return $this->parseNode($node);
61		},
62		$nodes
63		);
64		}
65
66		/**
67		* @param Node $node
68		*
69		* @throws \Pinq\Parsing\ASTException
70		* @return Expression
71		*/
72		protected function parseNode(Node $node)
73		{
74		switch (true) {
75		case $node instanceof Node\Stmt:
76		return $this->parseStatementNode($node);
77
78		case $node instanceof Node\Expr:
79		return $this->parseExpressionNode($node);
80
81		case $node instanceof Node\Param:
82		return $this->parseParameterNode($node);
83
84		case $node instanceof Node\Arg:
85		return $this->parseArgumentNode($node);
86
87		default:
88		throw new ASTException('Unsupported node type: %s', get_class($node));
89		}
90		}
91
92		/**
93		* @param $node
94		*
95		* @return Expression
96		*/
97		final public function parseNameNode($node)
98		{
99		if ($node instanceof Node\Name) {
100		return Expression::value($this->parseAbsoluteName($node));
101		} elseif (is_string($node)) {
102		return Expression::value($node);
103		}
104
105		return $this->parseNode($node);
106		}
107
108		protected function parseAbsoluteName(Node\Name $node)
109		{
110		return ($node->isFullyQualified() ? '\\' : '') . (string) $node;
111		}
112
113		private function parseParameterNode(Node\Param $node)
114		{
115		$type = $node->type;
116		if ($type !== null) {
117		$type = (string) $type;
118		$lowerType = strtolower($type);
119		if ($type[0] !== '\\' && $lowerType !== 'array' && $lowerType !== 'callable') {
120		$type = '\\' . $type;
121		}
122		}
123
124		return Expression::parameter(
125		$node->name,
126		$type,
127		$node->default === null ? null : $this->parseNode($node->default),
128		$node->byRef,
129		$node->variadic
130		);
131		}
132
133		private function parseArgumentNode(Node\Arg $node)
134		{
135		return Expression::argument(
136		$this->parseNode($node->value),
137		$node->unpack
138		);
139		}
140
141		// <editor-fold defaultstate="collapsed" desc="Expression node parsers">
142
143		public function parseExpressionNode(Node\Expr $node)
144		{
145		switch (true) {
146		case $mappedNode = $this->parseOperatorNode($node):
147		return $mappedNode;
148
149		case $node instanceof Node\Scalar
150		&& $mappedNode = $this->parseScalarNode($node):
151		return $mappedNode;
152
153		case $node instanceof Node\Expr\Variable:
154		return Expression::variable($this->parseNameNode($node->name));
155
156		case $node instanceof Node\Expr\Array_:
157		return $this->parseArrayNode($node);
158
159		case $node instanceof Node\Expr\FuncCall:
160		return $this->parseFunctionCallNode($node);
161
162		case $node instanceof Node\Expr\New_:
163		return Expression::newExpression(
164		$this->parseNameNode($node->class),
165		$this->parseNodes($node->args)
166		);
167
168		case $node instanceof Node\Expr\MethodCall:
169		return Expression::methodCall(
170		$this->parseNode($node->var),
171		$this->parseNameNode($node->name),
172		$this->parseNodes($node->args)
173		);
174
175		case $node instanceof Node\Expr\PropertyFetch:
176		return Expression::field(
177		$this->parseNode($node->var),
178		$this->parseNameNode($node->name)
179		);
180
181		case $node instanceof Node\Expr\ArrayDimFetch:
182		return Expression::index(
183		$this->parseNode($node->var),
184		$node->dim === null ? null : $this->parseNode($node->dim)
185		);
186
187		case $node instanceof Node\Expr\ConstFetch:
188		return Expression::constant($this->parseAbsoluteName($node->name));
189
190		case $node instanceof Node\Expr\ClassConstFetch:
191		return Expression::classConstant(
192		$this->parseNameNode($node->class),
193		$node->name
		0 ignored issues – show Bug introduced 2017-03-06 02:31 UTC by Report Bug Copy Issue Report It seems like `$node->name` can also be of type `object<PhpParser\Node\Expr\Error>`; however, `Pinq\Expressions\Expression::classConstant()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
194		);
195
196		case $node instanceof Node\Expr\StaticCall:
197		return Expression::staticMethodCall(
198		$this->parseNameNode($node->class),
199		$this->parseNameNode($node->name),
200		$this->parseNodes($node->args)
201		);
202
203		case $node instanceof Node\Expr\StaticPropertyFetch:
204		return Expression::staticField(
205		$this->parseNameNode($node->class),
206		$this->parseNameNode($node->name)
207		);
208
209		case $node instanceof Node\Expr\Ternary:
210		return $this->parseTernaryNode($node);
211
212		case $node instanceof Node\Expr\Closure:
213		return $this->parseClosureNode($node);
214
215		case $node instanceof Node\Expr\Empty_:
216		return Expression::emptyExpression($this->parseNode($node->expr));
217
218		case $node instanceof Node\Expr\Isset_:
219		return Expression::issetExpression($this->parseNodes($node->vars));
220
221		default:
222		throw new ASTException(
223		'Cannot parse AST with unknown expression node: %s',
224		get_class($node));
225		}
226		}
227
228		private function parseArrayNode(Node\Expr\Array_ $node)
229		{
230		$itemExpressions = [];
231
232		foreach ($node->items as $item) {
233		//Keys must match
234		$itemExpressions[] = Expression::arrayItem(
235		$item->key === null ? null : $this->parseNode($item->key),
236		$this->parseNode($item->value),
237		$item->byRef
238		);
239		}
240
241		return Expression::arrayExpression($itemExpressions);
242		}
243
244		private function parseFunctionCallNode(Node\Expr\FuncCall $node)
245		{
246		$nameExpression = $this->parseNameNode($node->name);
247
248		if ($nameExpression instanceof O\TraversalExpression \|\| $nameExpression instanceof O\VariableExpression) {
249		return Expression::invocation(
250		$nameExpression,
251		$this->parseNodes($node->args)
252		);
253		} else {
254		return Expression::functionCall(
255		$nameExpression,
256		$this->parseNodes($node->args)
257		);
258		}
259		}
260
261		private function parseTernaryNode(Node\Expr\Ternary $node)
262		{
263		return Expression::ternary(
264		$this->parseNode($node->cond),
265		$node->if === null ? null : $this->parseNode($node->if),
266		$this->parseNode($node->else)
267		);
268		}
269
270		private function parseClosureNode(Node\Expr\Closure $node)
271		{
272		$parameterExpressions = [];
273
274		foreach ($node->params as $parameterNode) {
275		$parameterExpressions[] = $this->parseParameterNode($parameterNode);
276		}
277
278		$usedVariables = [];
279		foreach ($node->uses as $usedVariable) {
280		$usedVariables[] = Expression::closureUsedVariable($usedVariable->var, $usedVariable->byRef);
281		}
282		$bodyExpressions = $this->parseNodes($node->stmts);
283
284		return Expression::closure(
285		$node->byRef,
286		$node->static,
287		$parameterExpressions,
288		$usedVariables,
289		$bodyExpressions
290		);
291		}
292
293		private function parseScalarNode(Node\Scalar $node)
294		{
295		switch (true) {
296		case $node instanceof Node\Scalar\DNumber:
297		case $node instanceof Node\Scalar\LNumber:
298		case $node instanceof Node\Scalar\String_:
299		return Expression::value($node->value);
300
301		case $node instanceof Node\Scalar\MagicConst\Line:
302		return Expression::value($node->getAttribute('startLine'));
303
304		case $node instanceof Node\Scalar\MagicConst:
305		return Expression::constant($node->getName());
306
307		default:
308		return;
309		}
310		}
311
312		// </editor-fold>
313
314		// <editor-fold defaultstate="collapsed" desc="Statement node parsers">
315
316		private function parseStatementNode(Node\Stmt $node)
317		{
318		switch (true) {
319
320		case $node instanceof Node\Stmt\Return_:
321		return Expression::returnExpression($node->expr !== null ? $this->parseNode($node->expr) : null);
322
323		case $node instanceof Node\Stmt\Throw_:
324		return Expression::throwExpression($this->parseNode($node->expr));
325
326		case $node instanceof Node\Stmt\Unset_:
327		return Expression::unsetExpression($this->parseNodes($node->vars));
328
329		default:
330		$this->verifyNotControlStructure($node);
331		throw new ASTException(
332		'Cannot parse AST with unknown statement node: %s',
333		get_class($node));
334		}
335		}
336
337		private static $constructStructureMap = [
338		'Do' => ASTException::DO_WHILE_LOOP,
339		'For' => ASTException::FOR_LOOP,
340		'Foreach' => ASTException::FOREACH_LOOP,
341		'Goto' => ASTException::GOTO_STATEMENT,
342		'If' => ASTException::IF_STATEMENT,
343		'Switch' => ASTException::SWITCH_STATEMENT,
344		'TryCatch' => ASTException::TRY_CATCH_STATEMENT,
345		'While' => ASTException::WHILE_LOOP
346		];
347
348		private function verifyNotControlStructure(Node\Stmt $node)
349		{
350		$nodeType = str_replace('Stmt_', '', $node->getType());
351
352		if (isset(self::$constructStructureMap[$nodeType])) {
353		throw ASTException::containsControlStructure(
354		self::$constructStructureMap[$nodeType],
355		$node->getAttribute('startLine')
356		);
357		}
358		}
359
360		// </editor-fold>
361
362		// <editor-fold defaultstate="collapsed" desc="Operator node maps">
363
364		private function parseOperatorNode(Node\Expr $node)
365		{
366		$nodeType = str_replace('Expr_', '', $node->getType());
367		switch (true) {
368
369	View Code Duplication	case isset(self::$assignOperatorsMap[$nodeType]):
370		return Expression::assign(
371		$this->parseNode($node->var),
372		self::$assignOperatorsMap[$nodeType],
373		$this->parseNode($node->expr)
374		);
375
376		case $node instanceof Node\Expr\Instanceof_:
377		return Expression::binaryOperation(
378		$this->parseNode($node->expr),
379		Operators\Binary::IS_INSTANCE_OF,
380		$this->parseNameNode($node->class)
381		);
382
383		case isset(self::$binaryOperatorsMap[$nodeType]):
384		return Expression::binaryOperation(
385		$this->parseNode($node->left),
386		self::$binaryOperatorsMap[$nodeType],
387		$this->parseNode($node->right)
388		);
389
390	View Code Duplication	case isset(self::$unaryOperatorsMap[$nodeType]):
391		return Expression::unaryOperation(
392		self::$unaryOperatorsMap[$nodeType],
393		$this->parseNode(isset($node->expr) ? $node->expr : $node->var)
394		);
395
396		case isset(self::$castOperatorMap[$nodeType]):
397		return Expression::cast(
398		self::$castOperatorMap[$nodeType],
399		$this->parseNode($node->expr)
400		);
401
402		default:
403		return null;
404		}
405		}
406
407		private static $unaryOperatorsMap = [
408		'BitwiseNot' => Operators\Unary::BITWISE_NOT,
409		'BooleanNot' => Operators\Unary::NOT,
410		'PostInc' => Operators\Unary::INCREMENT,
411		'PostDec' => Operators\Unary::DECREMENT,
412		'PreInc' => Operators\Unary::PRE_INCREMENT,
413		'PreDec' => Operators\Unary::PRE_DECREMENT,
414		'UnaryMinus' => Operators\Unary::NEGATION,
415		'UnaryPlus' => Operators\Unary::PLUS
416		];
417
418		private static $castOperatorMap = [
419		'Cast_Array' => Operators\Cast::ARRAY_CAST,
420		'Cast_Bool' => Operators\Cast::BOOLEAN,
421		'Cast_Double' => Operators\Cast::DOUBLE,
422		'Cast_Int' => Operators\Cast::INTEGER,
423		'Cast_Object' => Operators\Cast::OBJECT,
424		'Cast_String' => Operators\Cast::STRING
425		];
426
427		private static $binaryOperatorsMap = [
428		'BinaryOp_BitwiseAnd' => Operators\Binary::BITWISE_AND,
429		'BinaryOp_BitwiseOr' => Operators\Binary::BITWISE_OR,
430		'BinaryOp_BitwiseXor' => Operators\Binary::BITWISE_XOR,
431		'BinaryOp_ShiftLeft' => Operators\Binary::SHIFT_LEFT,
432		'BinaryOp_ShiftRight' => Operators\Binary::SHIFT_RIGHT,
433		'BinaryOp_BooleanAnd' => Operators\Binary::LOGICAL_AND,
434		'BinaryOp_BooleanOr' => Operators\Binary::LOGICAL_OR,
435		'BinaryOp_LogicalAnd' => Operators\Binary::LOGICAL_AND,
436		'BinaryOp_LogicalOr' => Operators\Binary::LOGICAL_OR,
437		'BinaryOp_Plus' => Operators\Binary::ADDITION,
438		'BinaryOp_Minus' => Operators\Binary::SUBTRACTION,
439		'BinaryOp_Mul' => Operators\Binary::MULTIPLICATION,
440		'BinaryOp_Div' => Operators\Binary::DIVISION,
441		'BinaryOp_Mod' => Operators\Binary::MODULUS,
442		'BinaryOp_Pow' => Operators\Binary::POWER,
443		'BinaryOp_Concat' => Operators\Binary::CONCATENATION,
444		'BinaryOp_Equal' => Operators\Binary::EQUALITY,
445		'BinaryOp_Identical' => Operators\Binary::IDENTITY,
446		'BinaryOp_NotEqual' => Operators\Binary::INEQUALITY,
447		'BinaryOp_NotIdentical' => Operators\Binary::NOT_IDENTICAL,
448		'BinaryOp_Smaller' => Operators\Binary::LESS_THAN,
449		'BinaryOp_SmallerOrEqual' => Operators\Binary::LESS_THAN_OR_EQUAL_TO,
450		'BinaryOp_Greater' => Operators\Binary::GREATER_THAN,
451		'BinaryOp_GreaterOrEqual' => Operators\Binary::GREATER_THAN_OR_EQUAL_TO
452		];
453
454		private static $assignOperatorsMap = [
455		'Assign' => Operators\Assignment::EQUAL,
456		'AssignRef' => Operators\Assignment::EQUAL_REFERENCE,
457		'AssignOp_BitwiseAnd' => Operators\Assignment::BITWISE_AND,
458		'AssignOp_BitwiseOr' => Operators\Assignment::BITWISE_OR,
459		'AssignOp_BitwiseXor' => Operators\Assignment::BITWISE_XOR,
460		'AssignOp_Concat' => Operators\Assignment::CONCATENATE,
461		'AssignOp_Div' => Operators\Assignment::DIVISION,
462		'AssignOp_Minus' => Operators\Assignment::SUBTRACTION,
463		'AssignOp_Mod' => Operators\Assignment::MODULUS,
464		'AssignOp_Mul' => Operators\Assignment::MULTIPLICATION,
465		'AssignOp_Pow' => Operators\Assignment::POWER,
466		'AssignOp_Plus' => Operators\Assignment::ADDITION,
467		'AssignOp_ShiftLeft' => Operators\Assignment::SHIFT_LEFT,
468		'AssignOp_ShiftRight' => Operators\Assignment::SHIFT_RIGHT
469		];
470
471		// </editor-fold>
472		}
473

TimeToogo / Pinq

GitHub Access Token became invalid

AST::parseParameterNode() B last analyzed 2017-09-06 06:30 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AST::parseParameterNode() B
last analyzed 2017-09-06 06:30 UTC