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

ExpressionWalker::walkReturn() A
last analyzed 2017-09-06 06:30 UTC

↳ Parent: ExpressionWalker

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php

namespace Pinq\Expressions;

/**
 * Base class for traversing or manipulating an expression tree
 *
 * @author Elliot Levin <[email protected]>
 */
class ExpressionWalker
{
    /**
     * Walks the expression tree and returns the updated expression tree.
     *
     * @param Expression $expression
     *
     * @return Expression|null
     */
    final public function walk(Expression $expression = null)
    {
        if ($expression === null) {
            return null;
        }

        return $this->doWalk($expression);
    }

    /**
     * @param Expression $expression
     *
     * @return Expression
     */
    protected function doWalk(Expression $expression)
    {
        return $expression->traverse($this);
    }

    /**
     * @param Expression|null[] $expressions
     *
     * @return Expression[]
     */
    final public function walkAll(array $expressions)
    {
        return $this->doWalkAll($expressions);
    }

    /**
     * @param Expression|null[] $expressions
     *
     * @return Expression[]
     */
    protected function doWalkAll(array $expressions)
    {
        foreach ($expressions as $key => $expression) {
            $expressions[$key] = $this->walk($expression);
        }

        return $expressions;
    }

    public function walkArray(ArrayExpression $expression)
    {
        return $expression->update(
                $this->walkAll($expression->getItems())
        );
    }

    public function walkArrayItem(ArrayItemExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getKey()),
                $this->walk($expression->getValue()),
                $expression->isReference()
        );
    }

    public function walkAssignment(AssignmentExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getAssignTo()),
                $expression->getOperator(),
                $this->walk($expression->getAssignmentValue())
        );
    }

    public function walkBinaryOperation(BinaryOperationExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getLeftOperand()),
                $expression->getOperator(),
                $this->walk($expression->getRightOperand())
        );
    }

    public function walkUnaryOperation(UnaryOperationExpression $expression)
    {
        return $expression->update(
                $expression->getOperator(),
                $this->walk($expression->getOperand())
        );
    }

    public function walkCast(CastExpression $expression)
    {
        return $expression->update(
                $expression->getCastType(),
                $this->walk($expression->getCastValue())
        );
    }

    public function walkConstant(ConstantExpression $expression)
    {
        return $expression;
    }

    public function walkClassConstant(ClassConstantExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getClass()),
                $expression->getName()
        );
    }

    public function walkEmpty(EmptyExpression $expression)
    {
        return $expression->update($this->walk($expression->getValue()));
    }

    public function walkIsset(IssetExpression $expression)
    {
        return $expression->update($this->walkAll($expression->getValues()));
    }

    public function walkUnset(UnsetExpression $expression)
    {
        return $expression->update($this->walkAll($expression->getValues()));
    }

    public function walkField(FieldExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getValue()),
                $this->walk($expression->getName())
        );
    }

    public function walkMethodCall(MethodCallExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getValue()),
                $this->walk($expression->getName()),
                $this->walkAll($expression->getArguments())
        );
    }

    public function walkIndex(IndexExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getValue()),
                $this->walk($expression->getIndex())
        );
    }

    public function walkInvocation(InvocationExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getValue()),
                $this->walkAll($expression->getArguments())
        );
    }

    public function walkFunctionCall(FunctionCallExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getName()),
                $this->walkAll($expression->getArguments())
        );
    }

    public function walkStaticMethodCall(StaticMethodCallExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getClass()),
                $this->walk($expression->getName()),
                $this->walkAll($expression->getArguments())
        );
    }

    public function walkStaticField(StaticFieldExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getClass()),
                $this->walk($expression->getName())
        );
    }

    public function walkNew(NewExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getClass()),
                $this->walkAll($expression->getArguments())
        );
    }

    public function walkReturn(ReturnExpression $expression)
    {
        return $expression->update($this->walk($expression->getValue()));
    }

    public function walkThrow(ThrowExpression $expression)
    {
        return $expression->update($this->walk($expression->getException()));
    }

    public function walkParameter(ParameterExpression $expression)
    {
        return $expression->update(
                $expression->getName(),
                $expression->getTypeHint(),
                $this->walk($expression->getDefaultValue()),
                $expression->isPassedByReference(),
                $expression->isVariadic()
        );
    }

    public function walkArgument(ArgumentExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getValue()),
                $expression->isUnpacked()
        );
    }

    public function walkTernary(TernaryExpression $expression)
    {
        return $expression->update(
                $this->walk($expression->getCondition()),
                $this->walk($expression->getIfTrue()),
                $this->walk($expression->getIfFalse())
        );
    }

    public function walkVariable(VariableExpression $expression)
    {
        return $expression->update($this->walk($expression->getName()));
    }

    public function walkValue(ValueExpression $expression)
    {
        return $expression;
    }

    public function walkClosure(ClosureExpression $expression)
    {
        return $expression->update(
                $expression->returnsReference(),
                $expression->isStatic(),
                $this->walkAll($expression->getParameters()),
                $this->walkAll($expression->getUsedVariables()),
                $this->walkAll($expression->getBodyExpressions())
        );
    }

    public function walkClosureUsedVariable(ClosureUsedVariableExpression $expression)
    {
        return $expression;
    }
}


1			<?php
2
3			namespace Pinq\Expressions;
4
5			/**
6			* Base class for traversing or manipulating an expression tree
7			*
8			* @author Elliot Levin <[email protected]>
9			*/
10			class ExpressionWalker
11			{
12			/**
13			* Walks the expression tree and returns the updated expression tree.
14			*
15			* @param Expression $expression
16			*
17			* @return Expression\|null
18			*/
19			final public function walk(Expression $expression = null)
20			{
21			if ($expression === null) {
22			return null;
23			}
24
25			return $this->doWalk($expression);
26			}
27
28			/**
29			* @param Expression $expression
30			*
31			* @return Expression
32			*/
33			protected function doWalk(Expression $expression)
34			{
35			return $expression->traverse($this);
36			}
37
38			/**
39			* @param Expression\|null[] $expressions
40			*
41			* @return Expression[]
42			*/
43			final public function walkAll(array $expressions)
44			{
45			return $this->doWalkAll($expressions);
46			}
47
48			/**
49			* @param Expression\|null[] $expressions
50			*
51			* @return Expression[]
52			*/
53			protected function doWalkAll(array $expressions)
54			{
55			foreach ($expressions as $key => $expression) {
56			$expressions[$key] = $this->walk($expression);
57			}
58
59			return $expressions;
60			}
61
62			public function walkArray(ArrayExpression $expression)
63			{
64			return $expression->update(
65			$this->walkAll($expression->getItems())
66			);
67			}
68
69			public function walkArrayItem(ArrayItemExpression $expression)
70			{
71			return $expression->update(
72			$this->walk($expression->getKey()),
73			$this->walk($expression->getValue()),
74			$expression->isReference()
75			);
76			}
77
78			public function walkAssignment(AssignmentExpression $expression)
79			{
80			return $expression->update(
81			$this->walk($expression->getAssignTo()),
82			$expression->getOperator(),
83			$this->walk($expression->getAssignmentValue())
84			);
85			}
86
87			public function walkBinaryOperation(BinaryOperationExpression $expression)
88			{
89			return $expression->update(
90			$this->walk($expression->getLeftOperand()),
91			$expression->getOperator(),
92			$this->walk($expression->getRightOperand())
93			);
94			}
95
96			public function walkUnaryOperation(UnaryOperationExpression $expression)
97			{
98			return $expression->update(
99			$expression->getOperator(),
100			$this->walk($expression->getOperand())
101			);
102			}
103
104			public function walkCast(CastExpression $expression)
105			{
106			return $expression->update(
107			$expression->getCastType(),
108			$this->walk($expression->getCastValue())
109			);
110			}
111
112			public function walkConstant(ConstantExpression $expression)
113			{
114			return $expression;
115			}
116
117			public function walkClassConstant(ClassConstantExpression $expression)
118			{
119			return $expression->update(
120			$this->walk($expression->getClass()),
121			$expression->getName()
122			);
123			}
124
125			public function walkEmpty(EmptyExpression $expression)
126			{
127			return $expression->update($this->walk($expression->getValue()));
128			}
129
130			public function walkIsset(IssetExpression $expression)
131			{
132			return $expression->update($this->walkAll($expression->getValues()));
133			}
134
135			public function walkUnset(UnsetExpression $expression)
136			{
137			return $expression->update($this->walkAll($expression->getValues()));
138			}
139
140			public function walkField(FieldExpression $expression)
141			{
142			return $expression->update(
143			$this->walk($expression->getValue()),
144			$this->walk($expression->getName())
145			);
146			}
147
148			public function walkMethodCall(MethodCallExpression $expression)
149			{
150			return $expression->update(
151			$this->walk($expression->getValue()),
152			$this->walk($expression->getName()),
153			$this->walkAll($expression->getArguments())
154			);
155			}
156
157			public function walkIndex(IndexExpression $expression)
158			{
159			return $expression->update(
160			$this->walk($expression->getValue()),
161			$this->walk($expression->getIndex())
162			);
163			}
164
165			public function walkInvocation(InvocationExpression $expression)
166			{
167			return $expression->update(
168			$this->walk($expression->getValue()),
169			$this->walkAll($expression->getArguments())
170			);
171			}
172
173			public function walkFunctionCall(FunctionCallExpression $expression)
174			{
175			return $expression->update(
176			$this->walk($expression->getName()),
177			$this->walkAll($expression->getArguments())
178			);
179			}
180
181			public function walkStaticMethodCall(StaticMethodCallExpression $expression)
182			{
183			return $expression->update(
184			$this->walk($expression->getClass()),
185			$this->walk($expression->getName()),
186			$this->walkAll($expression->getArguments())
187			);
188			}
189
190			public function walkStaticField(StaticFieldExpression $expression)
191			{
192			return $expression->update(
193			$this->walk($expression->getClass()),
194			$this->walk($expression->getName())
195			);
196			}
197
198			public function walkNew(NewExpression $expression)
199			{
200			return $expression->update(
201			$this->walk($expression->getClass()),
202			$this->walkAll($expression->getArguments())
203			);
204			}
205
206			public function walkReturn(ReturnExpression $expression)
207			{
208			return $expression->update($this->walk($expression->getValue()));
209			}
210
211			public function walkThrow(ThrowExpression $expression)
212			{
213			return $expression->update($this->walk($expression->getException()));
214			}
215
216			public function walkParameter(ParameterExpression $expression)
217			{
218			return $expression->update(
219			$expression->getName(),
220			$expression->getTypeHint(),
221			$this->walk($expression->getDefaultValue()),
222			$expression->isPassedByReference(),
223			$expression->isVariadic()
224			);
225			}
226
227			public function walkArgument(ArgumentExpression $expression)
228			{
229			return $expression->update(
230			$this->walk($expression->getValue()),
231			$expression->isUnpacked()
232			);
233			}
234
235			public function walkTernary(TernaryExpression $expression)
236			{
237			return $expression->update(
238			$this->walk($expression->getCondition()),
239			$this->walk($expression->getIfTrue()),
240			$this->walk($expression->getIfFalse())
241			);
242			}
243
244			public function walkVariable(VariableExpression $expression)
245			{
246			return $expression->update($this->walk($expression->getName()));
247			}
248
249			public function walkValue(ValueExpression $expression)
250			{
251			return $expression;
252			}
253
254			public function walkClosure(ClosureExpression $expression)
255			{
256			return $expression->update(
257			$expression->returnsReference(),
258			$expression->isStatic(),
259			$this->walkAll($expression->getParameters()),
260			$this->walkAll($expression->getUsedVariables()),
261			$this->walkAll($expression->getBodyExpressions())
262			);
263			}
264
265			public function walkClosureUsedVariable(ClosureUsedVariableExpression $expression)
266			{
267			return $expression;
268			}
269			}
270

TimeToogo / Pinq

GitHub Access Token became invalid

ExpressionWalker::walkReturn() A last analyzed 2017-09-06 06:30 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ExpressionWalker::walkReturn() A
last analyzed 2017-09-06 06:30 UTC